1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package workdocs 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/workdocs/types" 10 smithy "github.com/aws/smithy-go" 11 "github.com/aws/smithy-go/encoding/httpbinding" 12 smithyjson "github.com/aws/smithy-go/encoding/json" 13 "github.com/aws/smithy-go/middleware" 14 smithytime "github.com/aws/smithy-go/time" 15 smithyhttp "github.com/aws/smithy-go/transport/http" 16) 17 18type awsRestjson1_serializeOpAbortDocumentVersionUpload struct { 19} 20 21func (*awsRestjson1_serializeOpAbortDocumentVersionUpload) ID() string { 22 return "OperationSerializer" 23} 24 25func (m *awsRestjson1_serializeOpAbortDocumentVersionUpload) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 26 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 27) { 28 request, ok := in.Request.(*smithyhttp.Request) 29 if !ok { 30 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 31 } 32 33 input, ok := in.Parameters.(*AbortDocumentVersionUploadInput) 34 _ = input 35 if !ok { 36 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 37 } 38 39 opPath, opQuery := httpbinding.SplitURI("/api/v1/documents/{DocumentId}/versions/{VersionId}") 40 request.URL.Path = opPath 41 if len(request.URL.RawQuery) > 0 { 42 request.URL.RawQuery = "&" + opQuery 43 } else { 44 request.URL.RawQuery = opQuery 45 } 46 47 request.Method = "DELETE" 48 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 49 if err != nil { 50 return out, metadata, &smithy.SerializationError{Err: err} 51 } 52 53 if err := awsRestjson1_serializeOpHttpBindingsAbortDocumentVersionUploadInput(input, restEncoder); err != nil { 54 return out, metadata, &smithy.SerializationError{Err: err} 55 } 56 57 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 58 return out, metadata, &smithy.SerializationError{Err: err} 59 } 60 in.Request = request 61 62 return next.HandleSerialize(ctx, in) 63} 64func awsRestjson1_serializeOpHttpBindingsAbortDocumentVersionUploadInput(v *AbortDocumentVersionUploadInput, encoder *httpbinding.Encoder) error { 65 if v == nil { 66 return fmt.Errorf("unsupported serialization of nil %T", v) 67 } 68 69 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 70 locationName := "Authentication" 71 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 72 } 73 74 if v.DocumentId == nil || len(*v.DocumentId) == 0 { 75 return &smithy.SerializationError{Err: fmt.Errorf("input member DocumentId must not be empty")} 76 } 77 if v.DocumentId != nil { 78 if err := encoder.SetURI("DocumentId").String(*v.DocumentId); err != nil { 79 return err 80 } 81 } 82 83 if v.VersionId == nil || len(*v.VersionId) == 0 { 84 return &smithy.SerializationError{Err: fmt.Errorf("input member VersionId must not be empty")} 85 } 86 if v.VersionId != nil { 87 if err := encoder.SetURI("VersionId").String(*v.VersionId); err != nil { 88 return err 89 } 90 } 91 92 return nil 93} 94 95type awsRestjson1_serializeOpActivateUser struct { 96} 97 98func (*awsRestjson1_serializeOpActivateUser) ID() string { 99 return "OperationSerializer" 100} 101 102func (m *awsRestjson1_serializeOpActivateUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 103 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 104) { 105 request, ok := in.Request.(*smithyhttp.Request) 106 if !ok { 107 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 108 } 109 110 input, ok := in.Parameters.(*ActivateUserInput) 111 _ = input 112 if !ok { 113 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 114 } 115 116 opPath, opQuery := httpbinding.SplitURI("/api/v1/users/{UserId}/activation") 117 request.URL.Path = opPath 118 if len(request.URL.RawQuery) > 0 { 119 request.URL.RawQuery = "&" + opQuery 120 } else { 121 request.URL.RawQuery = opQuery 122 } 123 124 request.Method = "POST" 125 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 126 if err != nil { 127 return out, metadata, &smithy.SerializationError{Err: err} 128 } 129 130 if err := awsRestjson1_serializeOpHttpBindingsActivateUserInput(input, restEncoder); err != nil { 131 return out, metadata, &smithy.SerializationError{Err: err} 132 } 133 134 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 135 return out, metadata, &smithy.SerializationError{Err: err} 136 } 137 in.Request = request 138 139 return next.HandleSerialize(ctx, in) 140} 141func awsRestjson1_serializeOpHttpBindingsActivateUserInput(v *ActivateUserInput, encoder *httpbinding.Encoder) error { 142 if v == nil { 143 return fmt.Errorf("unsupported serialization of nil %T", v) 144 } 145 146 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 147 locationName := "Authentication" 148 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 149 } 150 151 if v.UserId == nil || len(*v.UserId) == 0 { 152 return &smithy.SerializationError{Err: fmt.Errorf("input member UserId must not be empty")} 153 } 154 if v.UserId != nil { 155 if err := encoder.SetURI("UserId").String(*v.UserId); err != nil { 156 return err 157 } 158 } 159 160 return nil 161} 162 163type awsRestjson1_serializeOpAddResourcePermissions struct { 164} 165 166func (*awsRestjson1_serializeOpAddResourcePermissions) ID() string { 167 return "OperationSerializer" 168} 169 170func (m *awsRestjson1_serializeOpAddResourcePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 171 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 172) { 173 request, ok := in.Request.(*smithyhttp.Request) 174 if !ok { 175 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 176 } 177 178 input, ok := in.Parameters.(*AddResourcePermissionsInput) 179 _ = input 180 if !ok { 181 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 182 } 183 184 opPath, opQuery := httpbinding.SplitURI("/api/v1/resources/{ResourceId}/permissions") 185 request.URL.Path = opPath 186 if len(request.URL.RawQuery) > 0 { 187 request.URL.RawQuery = "&" + opQuery 188 } else { 189 request.URL.RawQuery = opQuery 190 } 191 192 request.Method = "POST" 193 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 194 if err != nil { 195 return out, metadata, &smithy.SerializationError{Err: err} 196 } 197 198 if err := awsRestjson1_serializeOpHttpBindingsAddResourcePermissionsInput(input, restEncoder); err != nil { 199 return out, metadata, &smithy.SerializationError{Err: err} 200 } 201 202 restEncoder.SetHeader("Content-Type").String("application/json") 203 204 jsonEncoder := smithyjson.NewEncoder() 205 if err := awsRestjson1_serializeOpDocumentAddResourcePermissionsInput(input, jsonEncoder.Value); err != nil { 206 return out, metadata, &smithy.SerializationError{Err: err} 207 } 208 209 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 210 return out, metadata, &smithy.SerializationError{Err: err} 211 } 212 213 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 214 return out, metadata, &smithy.SerializationError{Err: err} 215 } 216 in.Request = request 217 218 return next.HandleSerialize(ctx, in) 219} 220func awsRestjson1_serializeOpHttpBindingsAddResourcePermissionsInput(v *AddResourcePermissionsInput, encoder *httpbinding.Encoder) error { 221 if v == nil { 222 return fmt.Errorf("unsupported serialization of nil %T", v) 223 } 224 225 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 226 locationName := "Authentication" 227 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 228 } 229 230 if v.ResourceId == nil || len(*v.ResourceId) == 0 { 231 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceId must not be empty")} 232 } 233 if v.ResourceId != nil { 234 if err := encoder.SetURI("ResourceId").String(*v.ResourceId); err != nil { 235 return err 236 } 237 } 238 239 return nil 240} 241 242func awsRestjson1_serializeOpDocumentAddResourcePermissionsInput(v *AddResourcePermissionsInput, value smithyjson.Value) error { 243 object := value.Object() 244 defer object.Close() 245 246 if v.NotificationOptions != nil { 247 ok := object.Key("NotificationOptions") 248 if err := awsRestjson1_serializeDocumentNotificationOptions(v.NotificationOptions, ok); err != nil { 249 return err 250 } 251 } 252 253 if v.Principals != nil { 254 ok := object.Key("Principals") 255 if err := awsRestjson1_serializeDocumentSharePrincipalList(v.Principals, ok); err != nil { 256 return err 257 } 258 } 259 260 return nil 261} 262 263type awsRestjson1_serializeOpCreateComment struct { 264} 265 266func (*awsRestjson1_serializeOpCreateComment) ID() string { 267 return "OperationSerializer" 268} 269 270func (m *awsRestjson1_serializeOpCreateComment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 271 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 272) { 273 request, ok := in.Request.(*smithyhttp.Request) 274 if !ok { 275 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 276 } 277 278 input, ok := in.Parameters.(*CreateCommentInput) 279 _ = input 280 if !ok { 281 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 282 } 283 284 opPath, opQuery := httpbinding.SplitURI("/api/v1/documents/{DocumentId}/versions/{VersionId}/comment") 285 request.URL.Path = opPath 286 if len(request.URL.RawQuery) > 0 { 287 request.URL.RawQuery = "&" + opQuery 288 } else { 289 request.URL.RawQuery = opQuery 290 } 291 292 request.Method = "POST" 293 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 294 if err != nil { 295 return out, metadata, &smithy.SerializationError{Err: err} 296 } 297 298 if err := awsRestjson1_serializeOpHttpBindingsCreateCommentInput(input, restEncoder); err != nil { 299 return out, metadata, &smithy.SerializationError{Err: err} 300 } 301 302 restEncoder.SetHeader("Content-Type").String("application/json") 303 304 jsonEncoder := smithyjson.NewEncoder() 305 if err := awsRestjson1_serializeOpDocumentCreateCommentInput(input, jsonEncoder.Value); err != nil { 306 return out, metadata, &smithy.SerializationError{Err: err} 307 } 308 309 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 310 return out, metadata, &smithy.SerializationError{Err: err} 311 } 312 313 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 314 return out, metadata, &smithy.SerializationError{Err: err} 315 } 316 in.Request = request 317 318 return next.HandleSerialize(ctx, in) 319} 320func awsRestjson1_serializeOpHttpBindingsCreateCommentInput(v *CreateCommentInput, encoder *httpbinding.Encoder) error { 321 if v == nil { 322 return fmt.Errorf("unsupported serialization of nil %T", v) 323 } 324 325 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 326 locationName := "Authentication" 327 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 328 } 329 330 if v.DocumentId == nil || len(*v.DocumentId) == 0 { 331 return &smithy.SerializationError{Err: fmt.Errorf("input member DocumentId must not be empty")} 332 } 333 if v.DocumentId != nil { 334 if err := encoder.SetURI("DocumentId").String(*v.DocumentId); err != nil { 335 return err 336 } 337 } 338 339 if v.VersionId == nil || len(*v.VersionId) == 0 { 340 return &smithy.SerializationError{Err: fmt.Errorf("input member VersionId must not be empty")} 341 } 342 if v.VersionId != nil { 343 if err := encoder.SetURI("VersionId").String(*v.VersionId); err != nil { 344 return err 345 } 346 } 347 348 return nil 349} 350 351func awsRestjson1_serializeOpDocumentCreateCommentInput(v *CreateCommentInput, value smithyjson.Value) error { 352 object := value.Object() 353 defer object.Close() 354 355 if v.NotifyCollaborators { 356 ok := object.Key("NotifyCollaborators") 357 ok.Boolean(v.NotifyCollaborators) 358 } 359 360 if v.ParentId != nil { 361 ok := object.Key("ParentId") 362 ok.String(*v.ParentId) 363 } 364 365 if v.Text != nil { 366 ok := object.Key("Text") 367 ok.String(*v.Text) 368 } 369 370 if v.ThreadId != nil { 371 ok := object.Key("ThreadId") 372 ok.String(*v.ThreadId) 373 } 374 375 if len(v.Visibility) > 0 { 376 ok := object.Key("Visibility") 377 ok.String(string(v.Visibility)) 378 } 379 380 return nil 381} 382 383type awsRestjson1_serializeOpCreateCustomMetadata struct { 384} 385 386func (*awsRestjson1_serializeOpCreateCustomMetadata) ID() string { 387 return "OperationSerializer" 388} 389 390func (m *awsRestjson1_serializeOpCreateCustomMetadata) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 391 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 392) { 393 request, ok := in.Request.(*smithyhttp.Request) 394 if !ok { 395 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 396 } 397 398 input, ok := in.Parameters.(*CreateCustomMetadataInput) 399 _ = input 400 if !ok { 401 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 402 } 403 404 opPath, opQuery := httpbinding.SplitURI("/api/v1/resources/{ResourceId}/customMetadata") 405 request.URL.Path = opPath 406 if len(request.URL.RawQuery) > 0 { 407 request.URL.RawQuery = "&" + opQuery 408 } else { 409 request.URL.RawQuery = opQuery 410 } 411 412 request.Method = "PUT" 413 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 414 if err != nil { 415 return out, metadata, &smithy.SerializationError{Err: err} 416 } 417 418 if err := awsRestjson1_serializeOpHttpBindingsCreateCustomMetadataInput(input, restEncoder); err != nil { 419 return out, metadata, &smithy.SerializationError{Err: err} 420 } 421 422 restEncoder.SetHeader("Content-Type").String("application/json") 423 424 jsonEncoder := smithyjson.NewEncoder() 425 if err := awsRestjson1_serializeOpDocumentCreateCustomMetadataInput(input, jsonEncoder.Value); err != nil { 426 return out, metadata, &smithy.SerializationError{Err: err} 427 } 428 429 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 430 return out, metadata, &smithy.SerializationError{Err: err} 431 } 432 433 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 434 return out, metadata, &smithy.SerializationError{Err: err} 435 } 436 in.Request = request 437 438 return next.HandleSerialize(ctx, in) 439} 440func awsRestjson1_serializeOpHttpBindingsCreateCustomMetadataInput(v *CreateCustomMetadataInput, encoder *httpbinding.Encoder) error { 441 if v == nil { 442 return fmt.Errorf("unsupported serialization of nil %T", v) 443 } 444 445 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 446 locationName := "Authentication" 447 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 448 } 449 450 if v.ResourceId == nil || len(*v.ResourceId) == 0 { 451 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceId must not be empty")} 452 } 453 if v.ResourceId != nil { 454 if err := encoder.SetURI("ResourceId").String(*v.ResourceId); err != nil { 455 return err 456 } 457 } 458 459 if v.VersionId != nil { 460 encoder.SetQuery("versionid").String(*v.VersionId) 461 } 462 463 return nil 464} 465 466func awsRestjson1_serializeOpDocumentCreateCustomMetadataInput(v *CreateCustomMetadataInput, value smithyjson.Value) error { 467 object := value.Object() 468 defer object.Close() 469 470 if v.CustomMetadata != nil { 471 ok := object.Key("CustomMetadata") 472 if err := awsRestjson1_serializeDocumentCustomMetadataMap(v.CustomMetadata, ok); err != nil { 473 return err 474 } 475 } 476 477 return nil 478} 479 480type awsRestjson1_serializeOpCreateFolder struct { 481} 482 483func (*awsRestjson1_serializeOpCreateFolder) ID() string { 484 return "OperationSerializer" 485} 486 487func (m *awsRestjson1_serializeOpCreateFolder) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 488 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 489) { 490 request, ok := in.Request.(*smithyhttp.Request) 491 if !ok { 492 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 493 } 494 495 input, ok := in.Parameters.(*CreateFolderInput) 496 _ = input 497 if !ok { 498 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 499 } 500 501 opPath, opQuery := httpbinding.SplitURI("/api/v1/folders") 502 request.URL.Path = opPath 503 if len(request.URL.RawQuery) > 0 { 504 request.URL.RawQuery = "&" + opQuery 505 } else { 506 request.URL.RawQuery = opQuery 507 } 508 509 request.Method = "POST" 510 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 511 if err != nil { 512 return out, metadata, &smithy.SerializationError{Err: err} 513 } 514 515 if err := awsRestjson1_serializeOpHttpBindingsCreateFolderInput(input, restEncoder); err != nil { 516 return out, metadata, &smithy.SerializationError{Err: err} 517 } 518 519 restEncoder.SetHeader("Content-Type").String("application/json") 520 521 jsonEncoder := smithyjson.NewEncoder() 522 if err := awsRestjson1_serializeOpDocumentCreateFolderInput(input, jsonEncoder.Value); err != nil { 523 return out, metadata, &smithy.SerializationError{Err: err} 524 } 525 526 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 527 return out, metadata, &smithy.SerializationError{Err: err} 528 } 529 530 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 531 return out, metadata, &smithy.SerializationError{Err: err} 532 } 533 in.Request = request 534 535 return next.HandleSerialize(ctx, in) 536} 537func awsRestjson1_serializeOpHttpBindingsCreateFolderInput(v *CreateFolderInput, encoder *httpbinding.Encoder) error { 538 if v == nil { 539 return fmt.Errorf("unsupported serialization of nil %T", v) 540 } 541 542 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 543 locationName := "Authentication" 544 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 545 } 546 547 return nil 548} 549 550func awsRestjson1_serializeOpDocumentCreateFolderInput(v *CreateFolderInput, value smithyjson.Value) error { 551 object := value.Object() 552 defer object.Close() 553 554 if v.Name != nil { 555 ok := object.Key("Name") 556 ok.String(*v.Name) 557 } 558 559 if v.ParentFolderId != nil { 560 ok := object.Key("ParentFolderId") 561 ok.String(*v.ParentFolderId) 562 } 563 564 return nil 565} 566 567type awsRestjson1_serializeOpCreateLabels struct { 568} 569 570func (*awsRestjson1_serializeOpCreateLabels) ID() string { 571 return "OperationSerializer" 572} 573 574func (m *awsRestjson1_serializeOpCreateLabels) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 575 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 576) { 577 request, ok := in.Request.(*smithyhttp.Request) 578 if !ok { 579 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 580 } 581 582 input, ok := in.Parameters.(*CreateLabelsInput) 583 _ = input 584 if !ok { 585 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 586 } 587 588 opPath, opQuery := httpbinding.SplitURI("/api/v1/resources/{ResourceId}/labels") 589 request.URL.Path = opPath 590 if len(request.URL.RawQuery) > 0 { 591 request.URL.RawQuery = "&" + opQuery 592 } else { 593 request.URL.RawQuery = opQuery 594 } 595 596 request.Method = "PUT" 597 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 598 if err != nil { 599 return out, metadata, &smithy.SerializationError{Err: err} 600 } 601 602 if err := awsRestjson1_serializeOpHttpBindingsCreateLabelsInput(input, restEncoder); err != nil { 603 return out, metadata, &smithy.SerializationError{Err: err} 604 } 605 606 restEncoder.SetHeader("Content-Type").String("application/json") 607 608 jsonEncoder := smithyjson.NewEncoder() 609 if err := awsRestjson1_serializeOpDocumentCreateLabelsInput(input, jsonEncoder.Value); err != nil { 610 return out, metadata, &smithy.SerializationError{Err: err} 611 } 612 613 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 614 return out, metadata, &smithy.SerializationError{Err: err} 615 } 616 617 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 618 return out, metadata, &smithy.SerializationError{Err: err} 619 } 620 in.Request = request 621 622 return next.HandleSerialize(ctx, in) 623} 624func awsRestjson1_serializeOpHttpBindingsCreateLabelsInput(v *CreateLabelsInput, encoder *httpbinding.Encoder) error { 625 if v == nil { 626 return fmt.Errorf("unsupported serialization of nil %T", v) 627 } 628 629 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 630 locationName := "Authentication" 631 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 632 } 633 634 if v.ResourceId == nil || len(*v.ResourceId) == 0 { 635 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceId must not be empty")} 636 } 637 if v.ResourceId != nil { 638 if err := encoder.SetURI("ResourceId").String(*v.ResourceId); err != nil { 639 return err 640 } 641 } 642 643 return nil 644} 645 646func awsRestjson1_serializeOpDocumentCreateLabelsInput(v *CreateLabelsInput, value smithyjson.Value) error { 647 object := value.Object() 648 defer object.Close() 649 650 if v.Labels != nil { 651 ok := object.Key("Labels") 652 if err := awsRestjson1_serializeDocumentSharedLabels(v.Labels, ok); err != nil { 653 return err 654 } 655 } 656 657 return nil 658} 659 660type awsRestjson1_serializeOpCreateNotificationSubscription struct { 661} 662 663func (*awsRestjson1_serializeOpCreateNotificationSubscription) ID() string { 664 return "OperationSerializer" 665} 666 667func (m *awsRestjson1_serializeOpCreateNotificationSubscription) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 668 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 669) { 670 request, ok := in.Request.(*smithyhttp.Request) 671 if !ok { 672 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 673 } 674 675 input, ok := in.Parameters.(*CreateNotificationSubscriptionInput) 676 _ = input 677 if !ok { 678 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 679 } 680 681 opPath, opQuery := httpbinding.SplitURI("/api/v1/organizations/{OrganizationId}/subscriptions") 682 request.URL.Path = opPath 683 if len(request.URL.RawQuery) > 0 { 684 request.URL.RawQuery = "&" + opQuery 685 } else { 686 request.URL.RawQuery = opQuery 687 } 688 689 request.Method = "POST" 690 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 691 if err != nil { 692 return out, metadata, &smithy.SerializationError{Err: err} 693 } 694 695 if err := awsRestjson1_serializeOpHttpBindingsCreateNotificationSubscriptionInput(input, restEncoder); err != nil { 696 return out, metadata, &smithy.SerializationError{Err: err} 697 } 698 699 restEncoder.SetHeader("Content-Type").String("application/json") 700 701 jsonEncoder := smithyjson.NewEncoder() 702 if err := awsRestjson1_serializeOpDocumentCreateNotificationSubscriptionInput(input, jsonEncoder.Value); err != nil { 703 return out, metadata, &smithy.SerializationError{Err: err} 704 } 705 706 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 707 return out, metadata, &smithy.SerializationError{Err: err} 708 } 709 710 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 711 return out, metadata, &smithy.SerializationError{Err: err} 712 } 713 in.Request = request 714 715 return next.HandleSerialize(ctx, in) 716} 717func awsRestjson1_serializeOpHttpBindingsCreateNotificationSubscriptionInput(v *CreateNotificationSubscriptionInput, encoder *httpbinding.Encoder) error { 718 if v == nil { 719 return fmt.Errorf("unsupported serialization of nil %T", v) 720 } 721 722 if v.OrganizationId == nil || len(*v.OrganizationId) == 0 { 723 return &smithy.SerializationError{Err: fmt.Errorf("input member OrganizationId must not be empty")} 724 } 725 if v.OrganizationId != nil { 726 if err := encoder.SetURI("OrganizationId").String(*v.OrganizationId); err != nil { 727 return err 728 } 729 } 730 731 return nil 732} 733 734func awsRestjson1_serializeOpDocumentCreateNotificationSubscriptionInput(v *CreateNotificationSubscriptionInput, value smithyjson.Value) error { 735 object := value.Object() 736 defer object.Close() 737 738 if v.Endpoint != nil { 739 ok := object.Key("Endpoint") 740 ok.String(*v.Endpoint) 741 } 742 743 if len(v.Protocol) > 0 { 744 ok := object.Key("Protocol") 745 ok.String(string(v.Protocol)) 746 } 747 748 if len(v.SubscriptionType) > 0 { 749 ok := object.Key("SubscriptionType") 750 ok.String(string(v.SubscriptionType)) 751 } 752 753 return nil 754} 755 756type awsRestjson1_serializeOpCreateUser struct { 757} 758 759func (*awsRestjson1_serializeOpCreateUser) ID() string { 760 return "OperationSerializer" 761} 762 763func (m *awsRestjson1_serializeOpCreateUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 764 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 765) { 766 request, ok := in.Request.(*smithyhttp.Request) 767 if !ok { 768 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 769 } 770 771 input, ok := in.Parameters.(*CreateUserInput) 772 _ = input 773 if !ok { 774 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 775 } 776 777 opPath, opQuery := httpbinding.SplitURI("/api/v1/users") 778 request.URL.Path = opPath 779 if len(request.URL.RawQuery) > 0 { 780 request.URL.RawQuery = "&" + opQuery 781 } else { 782 request.URL.RawQuery = opQuery 783 } 784 785 request.Method = "POST" 786 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 787 if err != nil { 788 return out, metadata, &smithy.SerializationError{Err: err} 789 } 790 791 if err := awsRestjson1_serializeOpHttpBindingsCreateUserInput(input, restEncoder); err != nil { 792 return out, metadata, &smithy.SerializationError{Err: err} 793 } 794 795 restEncoder.SetHeader("Content-Type").String("application/json") 796 797 jsonEncoder := smithyjson.NewEncoder() 798 if err := awsRestjson1_serializeOpDocumentCreateUserInput(input, jsonEncoder.Value); err != nil { 799 return out, metadata, &smithy.SerializationError{Err: err} 800 } 801 802 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 803 return out, metadata, &smithy.SerializationError{Err: err} 804 } 805 806 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 807 return out, metadata, &smithy.SerializationError{Err: err} 808 } 809 in.Request = request 810 811 return next.HandleSerialize(ctx, in) 812} 813func awsRestjson1_serializeOpHttpBindingsCreateUserInput(v *CreateUserInput, encoder *httpbinding.Encoder) error { 814 if v == nil { 815 return fmt.Errorf("unsupported serialization of nil %T", v) 816 } 817 818 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 819 locationName := "Authentication" 820 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 821 } 822 823 return nil 824} 825 826func awsRestjson1_serializeOpDocumentCreateUserInput(v *CreateUserInput, value smithyjson.Value) error { 827 object := value.Object() 828 defer object.Close() 829 830 if v.EmailAddress != nil { 831 ok := object.Key("EmailAddress") 832 ok.String(*v.EmailAddress) 833 } 834 835 if v.GivenName != nil { 836 ok := object.Key("GivenName") 837 ok.String(*v.GivenName) 838 } 839 840 if v.OrganizationId != nil { 841 ok := object.Key("OrganizationId") 842 ok.String(*v.OrganizationId) 843 } 844 845 if v.Password != nil { 846 ok := object.Key("Password") 847 ok.String(*v.Password) 848 } 849 850 if v.StorageRule != nil { 851 ok := object.Key("StorageRule") 852 if err := awsRestjson1_serializeDocumentStorageRuleType(v.StorageRule, ok); err != nil { 853 return err 854 } 855 } 856 857 if v.Surname != nil { 858 ok := object.Key("Surname") 859 ok.String(*v.Surname) 860 } 861 862 if v.TimeZoneId != nil { 863 ok := object.Key("TimeZoneId") 864 ok.String(*v.TimeZoneId) 865 } 866 867 if v.Username != nil { 868 ok := object.Key("Username") 869 ok.String(*v.Username) 870 } 871 872 return nil 873} 874 875type awsRestjson1_serializeOpDeactivateUser struct { 876} 877 878func (*awsRestjson1_serializeOpDeactivateUser) ID() string { 879 return "OperationSerializer" 880} 881 882func (m *awsRestjson1_serializeOpDeactivateUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 883 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 884) { 885 request, ok := in.Request.(*smithyhttp.Request) 886 if !ok { 887 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 888 } 889 890 input, ok := in.Parameters.(*DeactivateUserInput) 891 _ = input 892 if !ok { 893 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 894 } 895 896 opPath, opQuery := httpbinding.SplitURI("/api/v1/users/{UserId}/activation") 897 request.URL.Path = opPath 898 if len(request.URL.RawQuery) > 0 { 899 request.URL.RawQuery = "&" + opQuery 900 } else { 901 request.URL.RawQuery = opQuery 902 } 903 904 request.Method = "DELETE" 905 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 906 if err != nil { 907 return out, metadata, &smithy.SerializationError{Err: err} 908 } 909 910 if err := awsRestjson1_serializeOpHttpBindingsDeactivateUserInput(input, restEncoder); err != nil { 911 return out, metadata, &smithy.SerializationError{Err: err} 912 } 913 914 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 915 return out, metadata, &smithy.SerializationError{Err: err} 916 } 917 in.Request = request 918 919 return next.HandleSerialize(ctx, in) 920} 921func awsRestjson1_serializeOpHttpBindingsDeactivateUserInput(v *DeactivateUserInput, encoder *httpbinding.Encoder) error { 922 if v == nil { 923 return fmt.Errorf("unsupported serialization of nil %T", v) 924 } 925 926 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 927 locationName := "Authentication" 928 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 929 } 930 931 if v.UserId == nil || len(*v.UserId) == 0 { 932 return &smithy.SerializationError{Err: fmt.Errorf("input member UserId must not be empty")} 933 } 934 if v.UserId != nil { 935 if err := encoder.SetURI("UserId").String(*v.UserId); err != nil { 936 return err 937 } 938 } 939 940 return nil 941} 942 943type awsRestjson1_serializeOpDeleteComment struct { 944} 945 946func (*awsRestjson1_serializeOpDeleteComment) ID() string { 947 return "OperationSerializer" 948} 949 950func (m *awsRestjson1_serializeOpDeleteComment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 951 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 952) { 953 request, ok := in.Request.(*smithyhttp.Request) 954 if !ok { 955 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 956 } 957 958 input, ok := in.Parameters.(*DeleteCommentInput) 959 _ = input 960 if !ok { 961 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 962 } 963 964 opPath, opQuery := httpbinding.SplitURI("/api/v1/documents/{DocumentId}/versions/{VersionId}/comment/{CommentId}") 965 request.URL.Path = opPath 966 if len(request.URL.RawQuery) > 0 { 967 request.URL.RawQuery = "&" + opQuery 968 } else { 969 request.URL.RawQuery = opQuery 970 } 971 972 request.Method = "DELETE" 973 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 974 if err != nil { 975 return out, metadata, &smithy.SerializationError{Err: err} 976 } 977 978 if err := awsRestjson1_serializeOpHttpBindingsDeleteCommentInput(input, restEncoder); err != nil { 979 return out, metadata, &smithy.SerializationError{Err: err} 980 } 981 982 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 983 return out, metadata, &smithy.SerializationError{Err: err} 984 } 985 in.Request = request 986 987 return next.HandleSerialize(ctx, in) 988} 989func awsRestjson1_serializeOpHttpBindingsDeleteCommentInput(v *DeleteCommentInput, encoder *httpbinding.Encoder) error { 990 if v == nil { 991 return fmt.Errorf("unsupported serialization of nil %T", v) 992 } 993 994 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 995 locationName := "Authentication" 996 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 997 } 998 999 if v.CommentId == nil || len(*v.CommentId) == 0 { 1000 return &smithy.SerializationError{Err: fmt.Errorf("input member CommentId must not be empty")} 1001 } 1002 if v.CommentId != nil { 1003 if err := encoder.SetURI("CommentId").String(*v.CommentId); err != nil { 1004 return err 1005 } 1006 } 1007 1008 if v.DocumentId == nil || len(*v.DocumentId) == 0 { 1009 return &smithy.SerializationError{Err: fmt.Errorf("input member DocumentId must not be empty")} 1010 } 1011 if v.DocumentId != nil { 1012 if err := encoder.SetURI("DocumentId").String(*v.DocumentId); err != nil { 1013 return err 1014 } 1015 } 1016 1017 if v.VersionId == nil || len(*v.VersionId) == 0 { 1018 return &smithy.SerializationError{Err: fmt.Errorf("input member VersionId must not be empty")} 1019 } 1020 if v.VersionId != nil { 1021 if err := encoder.SetURI("VersionId").String(*v.VersionId); err != nil { 1022 return err 1023 } 1024 } 1025 1026 return nil 1027} 1028 1029type awsRestjson1_serializeOpDeleteCustomMetadata struct { 1030} 1031 1032func (*awsRestjson1_serializeOpDeleteCustomMetadata) ID() string { 1033 return "OperationSerializer" 1034} 1035 1036func (m *awsRestjson1_serializeOpDeleteCustomMetadata) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1037 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1038) { 1039 request, ok := in.Request.(*smithyhttp.Request) 1040 if !ok { 1041 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1042 } 1043 1044 input, ok := in.Parameters.(*DeleteCustomMetadataInput) 1045 _ = input 1046 if !ok { 1047 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1048 } 1049 1050 opPath, opQuery := httpbinding.SplitURI("/api/v1/resources/{ResourceId}/customMetadata") 1051 request.URL.Path = opPath 1052 if len(request.URL.RawQuery) > 0 { 1053 request.URL.RawQuery = "&" + opQuery 1054 } else { 1055 request.URL.RawQuery = opQuery 1056 } 1057 1058 request.Method = "DELETE" 1059 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1060 if err != nil { 1061 return out, metadata, &smithy.SerializationError{Err: err} 1062 } 1063 1064 if err := awsRestjson1_serializeOpHttpBindingsDeleteCustomMetadataInput(input, restEncoder); err != nil { 1065 return out, metadata, &smithy.SerializationError{Err: err} 1066 } 1067 1068 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1069 return out, metadata, &smithy.SerializationError{Err: err} 1070 } 1071 in.Request = request 1072 1073 return next.HandleSerialize(ctx, in) 1074} 1075func awsRestjson1_serializeOpHttpBindingsDeleteCustomMetadataInput(v *DeleteCustomMetadataInput, encoder *httpbinding.Encoder) error { 1076 if v == nil { 1077 return fmt.Errorf("unsupported serialization of nil %T", v) 1078 } 1079 1080 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 1081 locationName := "Authentication" 1082 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 1083 } 1084 1085 if v.DeleteAll { 1086 encoder.SetQuery("deleteAll").Boolean(v.DeleteAll) 1087 } 1088 1089 if v.Keys != nil { 1090 for i := range v.Keys { 1091 encoder.AddQuery("keys").String(v.Keys[i]) 1092 } 1093 } 1094 1095 if v.ResourceId == nil || len(*v.ResourceId) == 0 { 1096 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceId must not be empty")} 1097 } 1098 if v.ResourceId != nil { 1099 if err := encoder.SetURI("ResourceId").String(*v.ResourceId); err != nil { 1100 return err 1101 } 1102 } 1103 1104 if v.VersionId != nil { 1105 encoder.SetQuery("versionId").String(*v.VersionId) 1106 } 1107 1108 return nil 1109} 1110 1111type awsRestjson1_serializeOpDeleteDocument struct { 1112} 1113 1114func (*awsRestjson1_serializeOpDeleteDocument) ID() string { 1115 return "OperationSerializer" 1116} 1117 1118func (m *awsRestjson1_serializeOpDeleteDocument) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1119 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1120) { 1121 request, ok := in.Request.(*smithyhttp.Request) 1122 if !ok { 1123 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1124 } 1125 1126 input, ok := in.Parameters.(*DeleteDocumentInput) 1127 _ = input 1128 if !ok { 1129 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1130 } 1131 1132 opPath, opQuery := httpbinding.SplitURI("/api/v1/documents/{DocumentId}") 1133 request.URL.Path = opPath 1134 if len(request.URL.RawQuery) > 0 { 1135 request.URL.RawQuery = "&" + opQuery 1136 } else { 1137 request.URL.RawQuery = opQuery 1138 } 1139 1140 request.Method = "DELETE" 1141 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1142 if err != nil { 1143 return out, metadata, &smithy.SerializationError{Err: err} 1144 } 1145 1146 if err := awsRestjson1_serializeOpHttpBindingsDeleteDocumentInput(input, restEncoder); err != nil { 1147 return out, metadata, &smithy.SerializationError{Err: err} 1148 } 1149 1150 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1151 return out, metadata, &smithy.SerializationError{Err: err} 1152 } 1153 in.Request = request 1154 1155 return next.HandleSerialize(ctx, in) 1156} 1157func awsRestjson1_serializeOpHttpBindingsDeleteDocumentInput(v *DeleteDocumentInput, encoder *httpbinding.Encoder) error { 1158 if v == nil { 1159 return fmt.Errorf("unsupported serialization of nil %T", v) 1160 } 1161 1162 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 1163 locationName := "Authentication" 1164 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 1165 } 1166 1167 if v.DocumentId == nil || len(*v.DocumentId) == 0 { 1168 return &smithy.SerializationError{Err: fmt.Errorf("input member DocumentId must not be empty")} 1169 } 1170 if v.DocumentId != nil { 1171 if err := encoder.SetURI("DocumentId").String(*v.DocumentId); err != nil { 1172 return err 1173 } 1174 } 1175 1176 return nil 1177} 1178 1179type awsRestjson1_serializeOpDeleteFolder struct { 1180} 1181 1182func (*awsRestjson1_serializeOpDeleteFolder) ID() string { 1183 return "OperationSerializer" 1184} 1185 1186func (m *awsRestjson1_serializeOpDeleteFolder) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1187 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1188) { 1189 request, ok := in.Request.(*smithyhttp.Request) 1190 if !ok { 1191 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1192 } 1193 1194 input, ok := in.Parameters.(*DeleteFolderInput) 1195 _ = input 1196 if !ok { 1197 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1198 } 1199 1200 opPath, opQuery := httpbinding.SplitURI("/api/v1/folders/{FolderId}") 1201 request.URL.Path = opPath 1202 if len(request.URL.RawQuery) > 0 { 1203 request.URL.RawQuery = "&" + opQuery 1204 } else { 1205 request.URL.RawQuery = opQuery 1206 } 1207 1208 request.Method = "DELETE" 1209 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1210 if err != nil { 1211 return out, metadata, &smithy.SerializationError{Err: err} 1212 } 1213 1214 if err := awsRestjson1_serializeOpHttpBindingsDeleteFolderInput(input, restEncoder); err != nil { 1215 return out, metadata, &smithy.SerializationError{Err: err} 1216 } 1217 1218 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1219 return out, metadata, &smithy.SerializationError{Err: err} 1220 } 1221 in.Request = request 1222 1223 return next.HandleSerialize(ctx, in) 1224} 1225func awsRestjson1_serializeOpHttpBindingsDeleteFolderInput(v *DeleteFolderInput, encoder *httpbinding.Encoder) error { 1226 if v == nil { 1227 return fmt.Errorf("unsupported serialization of nil %T", v) 1228 } 1229 1230 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 1231 locationName := "Authentication" 1232 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 1233 } 1234 1235 if v.FolderId == nil || len(*v.FolderId) == 0 { 1236 return &smithy.SerializationError{Err: fmt.Errorf("input member FolderId must not be empty")} 1237 } 1238 if v.FolderId != nil { 1239 if err := encoder.SetURI("FolderId").String(*v.FolderId); err != nil { 1240 return err 1241 } 1242 } 1243 1244 return nil 1245} 1246 1247type awsRestjson1_serializeOpDeleteFolderContents struct { 1248} 1249 1250func (*awsRestjson1_serializeOpDeleteFolderContents) ID() string { 1251 return "OperationSerializer" 1252} 1253 1254func (m *awsRestjson1_serializeOpDeleteFolderContents) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1255 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1256) { 1257 request, ok := in.Request.(*smithyhttp.Request) 1258 if !ok { 1259 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1260 } 1261 1262 input, ok := in.Parameters.(*DeleteFolderContentsInput) 1263 _ = input 1264 if !ok { 1265 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1266 } 1267 1268 opPath, opQuery := httpbinding.SplitURI("/api/v1/folders/{FolderId}/contents") 1269 request.URL.Path = opPath 1270 if len(request.URL.RawQuery) > 0 { 1271 request.URL.RawQuery = "&" + opQuery 1272 } else { 1273 request.URL.RawQuery = opQuery 1274 } 1275 1276 request.Method = "DELETE" 1277 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1278 if err != nil { 1279 return out, metadata, &smithy.SerializationError{Err: err} 1280 } 1281 1282 if err := awsRestjson1_serializeOpHttpBindingsDeleteFolderContentsInput(input, restEncoder); err != nil { 1283 return out, metadata, &smithy.SerializationError{Err: err} 1284 } 1285 1286 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1287 return out, metadata, &smithy.SerializationError{Err: err} 1288 } 1289 in.Request = request 1290 1291 return next.HandleSerialize(ctx, in) 1292} 1293func awsRestjson1_serializeOpHttpBindingsDeleteFolderContentsInput(v *DeleteFolderContentsInput, encoder *httpbinding.Encoder) error { 1294 if v == nil { 1295 return fmt.Errorf("unsupported serialization of nil %T", v) 1296 } 1297 1298 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 1299 locationName := "Authentication" 1300 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 1301 } 1302 1303 if v.FolderId == nil || len(*v.FolderId) == 0 { 1304 return &smithy.SerializationError{Err: fmt.Errorf("input member FolderId must not be empty")} 1305 } 1306 if v.FolderId != nil { 1307 if err := encoder.SetURI("FolderId").String(*v.FolderId); err != nil { 1308 return err 1309 } 1310 } 1311 1312 return nil 1313} 1314 1315type awsRestjson1_serializeOpDeleteLabels struct { 1316} 1317 1318func (*awsRestjson1_serializeOpDeleteLabels) ID() string { 1319 return "OperationSerializer" 1320} 1321 1322func (m *awsRestjson1_serializeOpDeleteLabels) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1323 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1324) { 1325 request, ok := in.Request.(*smithyhttp.Request) 1326 if !ok { 1327 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1328 } 1329 1330 input, ok := in.Parameters.(*DeleteLabelsInput) 1331 _ = input 1332 if !ok { 1333 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1334 } 1335 1336 opPath, opQuery := httpbinding.SplitURI("/api/v1/resources/{ResourceId}/labels") 1337 request.URL.Path = opPath 1338 if len(request.URL.RawQuery) > 0 { 1339 request.URL.RawQuery = "&" + opQuery 1340 } else { 1341 request.URL.RawQuery = opQuery 1342 } 1343 1344 request.Method = "DELETE" 1345 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1346 if err != nil { 1347 return out, metadata, &smithy.SerializationError{Err: err} 1348 } 1349 1350 if err := awsRestjson1_serializeOpHttpBindingsDeleteLabelsInput(input, restEncoder); err != nil { 1351 return out, metadata, &smithy.SerializationError{Err: err} 1352 } 1353 1354 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1355 return out, metadata, &smithy.SerializationError{Err: err} 1356 } 1357 in.Request = request 1358 1359 return next.HandleSerialize(ctx, in) 1360} 1361func awsRestjson1_serializeOpHttpBindingsDeleteLabelsInput(v *DeleteLabelsInput, encoder *httpbinding.Encoder) error { 1362 if v == nil { 1363 return fmt.Errorf("unsupported serialization of nil %T", v) 1364 } 1365 1366 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 1367 locationName := "Authentication" 1368 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 1369 } 1370 1371 if v.DeleteAll { 1372 encoder.SetQuery("deleteAll").Boolean(v.DeleteAll) 1373 } 1374 1375 if v.Labels != nil { 1376 for i := range v.Labels { 1377 encoder.AddQuery("labels").String(v.Labels[i]) 1378 } 1379 } 1380 1381 if v.ResourceId == nil || len(*v.ResourceId) == 0 { 1382 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceId must not be empty")} 1383 } 1384 if v.ResourceId != nil { 1385 if err := encoder.SetURI("ResourceId").String(*v.ResourceId); err != nil { 1386 return err 1387 } 1388 } 1389 1390 return nil 1391} 1392 1393type awsRestjson1_serializeOpDeleteNotificationSubscription struct { 1394} 1395 1396func (*awsRestjson1_serializeOpDeleteNotificationSubscription) ID() string { 1397 return "OperationSerializer" 1398} 1399 1400func (m *awsRestjson1_serializeOpDeleteNotificationSubscription) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1401 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1402) { 1403 request, ok := in.Request.(*smithyhttp.Request) 1404 if !ok { 1405 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1406 } 1407 1408 input, ok := in.Parameters.(*DeleteNotificationSubscriptionInput) 1409 _ = input 1410 if !ok { 1411 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1412 } 1413 1414 opPath, opQuery := httpbinding.SplitURI("/api/v1/organizations/{OrganizationId}/subscriptions/{SubscriptionId}") 1415 request.URL.Path = opPath 1416 if len(request.URL.RawQuery) > 0 { 1417 request.URL.RawQuery = "&" + opQuery 1418 } else { 1419 request.URL.RawQuery = opQuery 1420 } 1421 1422 request.Method = "DELETE" 1423 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1424 if err != nil { 1425 return out, metadata, &smithy.SerializationError{Err: err} 1426 } 1427 1428 if err := awsRestjson1_serializeOpHttpBindingsDeleteNotificationSubscriptionInput(input, restEncoder); err != nil { 1429 return out, metadata, &smithy.SerializationError{Err: err} 1430 } 1431 1432 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1433 return out, metadata, &smithy.SerializationError{Err: err} 1434 } 1435 in.Request = request 1436 1437 return next.HandleSerialize(ctx, in) 1438} 1439func awsRestjson1_serializeOpHttpBindingsDeleteNotificationSubscriptionInput(v *DeleteNotificationSubscriptionInput, encoder *httpbinding.Encoder) error { 1440 if v == nil { 1441 return fmt.Errorf("unsupported serialization of nil %T", v) 1442 } 1443 1444 if v.OrganizationId == nil || len(*v.OrganizationId) == 0 { 1445 return &smithy.SerializationError{Err: fmt.Errorf("input member OrganizationId must not be empty")} 1446 } 1447 if v.OrganizationId != nil { 1448 if err := encoder.SetURI("OrganizationId").String(*v.OrganizationId); err != nil { 1449 return err 1450 } 1451 } 1452 1453 if v.SubscriptionId == nil || len(*v.SubscriptionId) == 0 { 1454 return &smithy.SerializationError{Err: fmt.Errorf("input member SubscriptionId must not be empty")} 1455 } 1456 if v.SubscriptionId != nil { 1457 if err := encoder.SetURI("SubscriptionId").String(*v.SubscriptionId); err != nil { 1458 return err 1459 } 1460 } 1461 1462 return nil 1463} 1464 1465type awsRestjson1_serializeOpDeleteUser struct { 1466} 1467 1468func (*awsRestjson1_serializeOpDeleteUser) ID() string { 1469 return "OperationSerializer" 1470} 1471 1472func (m *awsRestjson1_serializeOpDeleteUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1473 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1474) { 1475 request, ok := in.Request.(*smithyhttp.Request) 1476 if !ok { 1477 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1478 } 1479 1480 input, ok := in.Parameters.(*DeleteUserInput) 1481 _ = input 1482 if !ok { 1483 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1484 } 1485 1486 opPath, opQuery := httpbinding.SplitURI("/api/v1/users/{UserId}") 1487 request.URL.Path = opPath 1488 if len(request.URL.RawQuery) > 0 { 1489 request.URL.RawQuery = "&" + opQuery 1490 } else { 1491 request.URL.RawQuery = opQuery 1492 } 1493 1494 request.Method = "DELETE" 1495 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1496 if err != nil { 1497 return out, metadata, &smithy.SerializationError{Err: err} 1498 } 1499 1500 if err := awsRestjson1_serializeOpHttpBindingsDeleteUserInput(input, restEncoder); err != nil { 1501 return out, metadata, &smithy.SerializationError{Err: err} 1502 } 1503 1504 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1505 return out, metadata, &smithy.SerializationError{Err: err} 1506 } 1507 in.Request = request 1508 1509 return next.HandleSerialize(ctx, in) 1510} 1511func awsRestjson1_serializeOpHttpBindingsDeleteUserInput(v *DeleteUserInput, encoder *httpbinding.Encoder) error { 1512 if v == nil { 1513 return fmt.Errorf("unsupported serialization of nil %T", v) 1514 } 1515 1516 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 1517 locationName := "Authentication" 1518 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 1519 } 1520 1521 if v.UserId == nil || len(*v.UserId) == 0 { 1522 return &smithy.SerializationError{Err: fmt.Errorf("input member UserId must not be empty")} 1523 } 1524 if v.UserId != nil { 1525 if err := encoder.SetURI("UserId").String(*v.UserId); err != nil { 1526 return err 1527 } 1528 } 1529 1530 return nil 1531} 1532 1533type awsRestjson1_serializeOpDescribeActivities struct { 1534} 1535 1536func (*awsRestjson1_serializeOpDescribeActivities) ID() string { 1537 return "OperationSerializer" 1538} 1539 1540func (m *awsRestjson1_serializeOpDescribeActivities) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1541 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1542) { 1543 request, ok := in.Request.(*smithyhttp.Request) 1544 if !ok { 1545 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1546 } 1547 1548 input, ok := in.Parameters.(*DescribeActivitiesInput) 1549 _ = input 1550 if !ok { 1551 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1552 } 1553 1554 opPath, opQuery := httpbinding.SplitURI("/api/v1/activities") 1555 request.URL.Path = opPath 1556 if len(request.URL.RawQuery) > 0 { 1557 request.URL.RawQuery = "&" + opQuery 1558 } else { 1559 request.URL.RawQuery = opQuery 1560 } 1561 1562 request.Method = "GET" 1563 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1564 if err != nil { 1565 return out, metadata, &smithy.SerializationError{Err: err} 1566 } 1567 1568 if err := awsRestjson1_serializeOpHttpBindingsDescribeActivitiesInput(input, restEncoder); err != nil { 1569 return out, metadata, &smithy.SerializationError{Err: err} 1570 } 1571 1572 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1573 return out, metadata, &smithy.SerializationError{Err: err} 1574 } 1575 in.Request = request 1576 1577 return next.HandleSerialize(ctx, in) 1578} 1579func awsRestjson1_serializeOpHttpBindingsDescribeActivitiesInput(v *DescribeActivitiesInput, encoder *httpbinding.Encoder) error { 1580 if v == nil { 1581 return fmt.Errorf("unsupported serialization of nil %T", v) 1582 } 1583 1584 if v.ActivityTypes != nil { 1585 encoder.SetQuery("activityTypes").String(*v.ActivityTypes) 1586 } 1587 1588 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 1589 locationName := "Authentication" 1590 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 1591 } 1592 1593 if v.EndTime != nil { 1594 encoder.SetQuery("endTime").String(smithytime.FormatDateTime(*v.EndTime)) 1595 } 1596 1597 if v.IncludeIndirectActivities { 1598 encoder.SetQuery("includeIndirectActivities").Boolean(v.IncludeIndirectActivities) 1599 } 1600 1601 if v.Limit != nil { 1602 encoder.SetQuery("limit").Integer(*v.Limit) 1603 } 1604 1605 if v.Marker != nil { 1606 encoder.SetQuery("marker").String(*v.Marker) 1607 } 1608 1609 if v.OrganizationId != nil { 1610 encoder.SetQuery("organizationId").String(*v.OrganizationId) 1611 } 1612 1613 if v.ResourceId != nil { 1614 encoder.SetQuery("resourceId").String(*v.ResourceId) 1615 } 1616 1617 if v.StartTime != nil { 1618 encoder.SetQuery("startTime").String(smithytime.FormatDateTime(*v.StartTime)) 1619 } 1620 1621 if v.UserId != nil { 1622 encoder.SetQuery("userId").String(*v.UserId) 1623 } 1624 1625 return nil 1626} 1627 1628type awsRestjson1_serializeOpDescribeComments struct { 1629} 1630 1631func (*awsRestjson1_serializeOpDescribeComments) ID() string { 1632 return "OperationSerializer" 1633} 1634 1635func (m *awsRestjson1_serializeOpDescribeComments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1636 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1637) { 1638 request, ok := in.Request.(*smithyhttp.Request) 1639 if !ok { 1640 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1641 } 1642 1643 input, ok := in.Parameters.(*DescribeCommentsInput) 1644 _ = input 1645 if !ok { 1646 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1647 } 1648 1649 opPath, opQuery := httpbinding.SplitURI("/api/v1/documents/{DocumentId}/versions/{VersionId}/comments") 1650 request.URL.Path = opPath 1651 if len(request.URL.RawQuery) > 0 { 1652 request.URL.RawQuery = "&" + opQuery 1653 } else { 1654 request.URL.RawQuery = opQuery 1655 } 1656 1657 request.Method = "GET" 1658 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1659 if err != nil { 1660 return out, metadata, &smithy.SerializationError{Err: err} 1661 } 1662 1663 if err := awsRestjson1_serializeOpHttpBindingsDescribeCommentsInput(input, restEncoder); err != nil { 1664 return out, metadata, &smithy.SerializationError{Err: err} 1665 } 1666 1667 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1668 return out, metadata, &smithy.SerializationError{Err: err} 1669 } 1670 in.Request = request 1671 1672 return next.HandleSerialize(ctx, in) 1673} 1674func awsRestjson1_serializeOpHttpBindingsDescribeCommentsInput(v *DescribeCommentsInput, encoder *httpbinding.Encoder) error { 1675 if v == nil { 1676 return fmt.Errorf("unsupported serialization of nil %T", v) 1677 } 1678 1679 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 1680 locationName := "Authentication" 1681 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 1682 } 1683 1684 if v.DocumentId == nil || len(*v.DocumentId) == 0 { 1685 return &smithy.SerializationError{Err: fmt.Errorf("input member DocumentId must not be empty")} 1686 } 1687 if v.DocumentId != nil { 1688 if err := encoder.SetURI("DocumentId").String(*v.DocumentId); err != nil { 1689 return err 1690 } 1691 } 1692 1693 if v.Limit != nil { 1694 encoder.SetQuery("limit").Integer(*v.Limit) 1695 } 1696 1697 if v.Marker != nil { 1698 encoder.SetQuery("marker").String(*v.Marker) 1699 } 1700 1701 if v.VersionId == nil || len(*v.VersionId) == 0 { 1702 return &smithy.SerializationError{Err: fmt.Errorf("input member VersionId must not be empty")} 1703 } 1704 if v.VersionId != nil { 1705 if err := encoder.SetURI("VersionId").String(*v.VersionId); err != nil { 1706 return err 1707 } 1708 } 1709 1710 return nil 1711} 1712 1713type awsRestjson1_serializeOpDescribeDocumentVersions struct { 1714} 1715 1716func (*awsRestjson1_serializeOpDescribeDocumentVersions) ID() string { 1717 return "OperationSerializer" 1718} 1719 1720func (m *awsRestjson1_serializeOpDescribeDocumentVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1721 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1722) { 1723 request, ok := in.Request.(*smithyhttp.Request) 1724 if !ok { 1725 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1726 } 1727 1728 input, ok := in.Parameters.(*DescribeDocumentVersionsInput) 1729 _ = input 1730 if !ok { 1731 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1732 } 1733 1734 opPath, opQuery := httpbinding.SplitURI("/api/v1/documents/{DocumentId}/versions") 1735 request.URL.Path = opPath 1736 if len(request.URL.RawQuery) > 0 { 1737 request.URL.RawQuery = "&" + opQuery 1738 } else { 1739 request.URL.RawQuery = opQuery 1740 } 1741 1742 request.Method = "GET" 1743 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1744 if err != nil { 1745 return out, metadata, &smithy.SerializationError{Err: err} 1746 } 1747 1748 if err := awsRestjson1_serializeOpHttpBindingsDescribeDocumentVersionsInput(input, restEncoder); err != nil { 1749 return out, metadata, &smithy.SerializationError{Err: err} 1750 } 1751 1752 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1753 return out, metadata, &smithy.SerializationError{Err: err} 1754 } 1755 in.Request = request 1756 1757 return next.HandleSerialize(ctx, in) 1758} 1759func awsRestjson1_serializeOpHttpBindingsDescribeDocumentVersionsInput(v *DescribeDocumentVersionsInput, encoder *httpbinding.Encoder) error { 1760 if v == nil { 1761 return fmt.Errorf("unsupported serialization of nil %T", v) 1762 } 1763 1764 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 1765 locationName := "Authentication" 1766 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 1767 } 1768 1769 if v.DocumentId == nil || len(*v.DocumentId) == 0 { 1770 return &smithy.SerializationError{Err: fmt.Errorf("input member DocumentId must not be empty")} 1771 } 1772 if v.DocumentId != nil { 1773 if err := encoder.SetURI("DocumentId").String(*v.DocumentId); err != nil { 1774 return err 1775 } 1776 } 1777 1778 if v.Fields != nil { 1779 encoder.SetQuery("fields").String(*v.Fields) 1780 } 1781 1782 if v.Include != nil { 1783 encoder.SetQuery("include").String(*v.Include) 1784 } 1785 1786 if v.Limit != nil { 1787 encoder.SetQuery("limit").Integer(*v.Limit) 1788 } 1789 1790 if v.Marker != nil { 1791 encoder.SetQuery("marker").String(*v.Marker) 1792 } 1793 1794 return nil 1795} 1796 1797type awsRestjson1_serializeOpDescribeFolderContents struct { 1798} 1799 1800func (*awsRestjson1_serializeOpDescribeFolderContents) ID() string { 1801 return "OperationSerializer" 1802} 1803 1804func (m *awsRestjson1_serializeOpDescribeFolderContents) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1805 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1806) { 1807 request, ok := in.Request.(*smithyhttp.Request) 1808 if !ok { 1809 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1810 } 1811 1812 input, ok := in.Parameters.(*DescribeFolderContentsInput) 1813 _ = input 1814 if !ok { 1815 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1816 } 1817 1818 opPath, opQuery := httpbinding.SplitURI("/api/v1/folders/{FolderId}/contents") 1819 request.URL.Path = opPath 1820 if len(request.URL.RawQuery) > 0 { 1821 request.URL.RawQuery = "&" + opQuery 1822 } else { 1823 request.URL.RawQuery = opQuery 1824 } 1825 1826 request.Method = "GET" 1827 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1828 if err != nil { 1829 return out, metadata, &smithy.SerializationError{Err: err} 1830 } 1831 1832 if err := awsRestjson1_serializeOpHttpBindingsDescribeFolderContentsInput(input, restEncoder); err != nil { 1833 return out, metadata, &smithy.SerializationError{Err: err} 1834 } 1835 1836 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1837 return out, metadata, &smithy.SerializationError{Err: err} 1838 } 1839 in.Request = request 1840 1841 return next.HandleSerialize(ctx, in) 1842} 1843func awsRestjson1_serializeOpHttpBindingsDescribeFolderContentsInput(v *DescribeFolderContentsInput, encoder *httpbinding.Encoder) error { 1844 if v == nil { 1845 return fmt.Errorf("unsupported serialization of nil %T", v) 1846 } 1847 1848 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 1849 locationName := "Authentication" 1850 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 1851 } 1852 1853 if v.FolderId == nil || len(*v.FolderId) == 0 { 1854 return &smithy.SerializationError{Err: fmt.Errorf("input member FolderId must not be empty")} 1855 } 1856 if v.FolderId != nil { 1857 if err := encoder.SetURI("FolderId").String(*v.FolderId); err != nil { 1858 return err 1859 } 1860 } 1861 1862 if v.Include != nil { 1863 encoder.SetQuery("include").String(*v.Include) 1864 } 1865 1866 if v.Limit != nil { 1867 encoder.SetQuery("limit").Integer(*v.Limit) 1868 } 1869 1870 if v.Marker != nil { 1871 encoder.SetQuery("marker").String(*v.Marker) 1872 } 1873 1874 if len(v.Order) > 0 { 1875 encoder.SetQuery("order").String(string(v.Order)) 1876 } 1877 1878 if len(v.Sort) > 0 { 1879 encoder.SetQuery("sort").String(string(v.Sort)) 1880 } 1881 1882 if len(v.Type) > 0 { 1883 encoder.SetQuery("type").String(string(v.Type)) 1884 } 1885 1886 return nil 1887} 1888 1889type awsRestjson1_serializeOpDescribeGroups struct { 1890} 1891 1892func (*awsRestjson1_serializeOpDescribeGroups) ID() string { 1893 return "OperationSerializer" 1894} 1895 1896func (m *awsRestjson1_serializeOpDescribeGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1897 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1898) { 1899 request, ok := in.Request.(*smithyhttp.Request) 1900 if !ok { 1901 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1902 } 1903 1904 input, ok := in.Parameters.(*DescribeGroupsInput) 1905 _ = input 1906 if !ok { 1907 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1908 } 1909 1910 opPath, opQuery := httpbinding.SplitURI("/api/v1/groups") 1911 request.URL.Path = opPath 1912 if len(request.URL.RawQuery) > 0 { 1913 request.URL.RawQuery = "&" + opQuery 1914 } else { 1915 request.URL.RawQuery = opQuery 1916 } 1917 1918 request.Method = "GET" 1919 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1920 if err != nil { 1921 return out, metadata, &smithy.SerializationError{Err: err} 1922 } 1923 1924 if err := awsRestjson1_serializeOpHttpBindingsDescribeGroupsInput(input, restEncoder); err != nil { 1925 return out, metadata, &smithy.SerializationError{Err: err} 1926 } 1927 1928 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1929 return out, metadata, &smithy.SerializationError{Err: err} 1930 } 1931 in.Request = request 1932 1933 return next.HandleSerialize(ctx, in) 1934} 1935func awsRestjson1_serializeOpHttpBindingsDescribeGroupsInput(v *DescribeGroupsInput, encoder *httpbinding.Encoder) error { 1936 if v == nil { 1937 return fmt.Errorf("unsupported serialization of nil %T", v) 1938 } 1939 1940 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 1941 locationName := "Authentication" 1942 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 1943 } 1944 1945 if v.Limit != nil { 1946 encoder.SetQuery("limit").Integer(*v.Limit) 1947 } 1948 1949 if v.Marker != nil { 1950 encoder.SetQuery("marker").String(*v.Marker) 1951 } 1952 1953 if v.OrganizationId != nil { 1954 encoder.SetQuery("organizationId").String(*v.OrganizationId) 1955 } 1956 1957 if v.SearchQuery != nil { 1958 encoder.SetQuery("searchQuery").String(*v.SearchQuery) 1959 } 1960 1961 return nil 1962} 1963 1964type awsRestjson1_serializeOpDescribeNotificationSubscriptions struct { 1965} 1966 1967func (*awsRestjson1_serializeOpDescribeNotificationSubscriptions) ID() string { 1968 return "OperationSerializer" 1969} 1970 1971func (m *awsRestjson1_serializeOpDescribeNotificationSubscriptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1972 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1973) { 1974 request, ok := in.Request.(*smithyhttp.Request) 1975 if !ok { 1976 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1977 } 1978 1979 input, ok := in.Parameters.(*DescribeNotificationSubscriptionsInput) 1980 _ = input 1981 if !ok { 1982 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1983 } 1984 1985 opPath, opQuery := httpbinding.SplitURI("/api/v1/organizations/{OrganizationId}/subscriptions") 1986 request.URL.Path = opPath 1987 if len(request.URL.RawQuery) > 0 { 1988 request.URL.RawQuery = "&" + opQuery 1989 } else { 1990 request.URL.RawQuery = opQuery 1991 } 1992 1993 request.Method = "GET" 1994 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1995 if err != nil { 1996 return out, metadata, &smithy.SerializationError{Err: err} 1997 } 1998 1999 if err := awsRestjson1_serializeOpHttpBindingsDescribeNotificationSubscriptionsInput(input, restEncoder); err != nil { 2000 return out, metadata, &smithy.SerializationError{Err: err} 2001 } 2002 2003 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2004 return out, metadata, &smithy.SerializationError{Err: err} 2005 } 2006 in.Request = request 2007 2008 return next.HandleSerialize(ctx, in) 2009} 2010func awsRestjson1_serializeOpHttpBindingsDescribeNotificationSubscriptionsInput(v *DescribeNotificationSubscriptionsInput, encoder *httpbinding.Encoder) error { 2011 if v == nil { 2012 return fmt.Errorf("unsupported serialization of nil %T", v) 2013 } 2014 2015 if v.Limit != nil { 2016 encoder.SetQuery("limit").Integer(*v.Limit) 2017 } 2018 2019 if v.Marker != nil { 2020 encoder.SetQuery("marker").String(*v.Marker) 2021 } 2022 2023 if v.OrganizationId == nil || len(*v.OrganizationId) == 0 { 2024 return &smithy.SerializationError{Err: fmt.Errorf("input member OrganizationId must not be empty")} 2025 } 2026 if v.OrganizationId != nil { 2027 if err := encoder.SetURI("OrganizationId").String(*v.OrganizationId); err != nil { 2028 return err 2029 } 2030 } 2031 2032 return nil 2033} 2034 2035type awsRestjson1_serializeOpDescribeResourcePermissions struct { 2036} 2037 2038func (*awsRestjson1_serializeOpDescribeResourcePermissions) ID() string { 2039 return "OperationSerializer" 2040} 2041 2042func (m *awsRestjson1_serializeOpDescribeResourcePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2043 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2044) { 2045 request, ok := in.Request.(*smithyhttp.Request) 2046 if !ok { 2047 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2048 } 2049 2050 input, ok := in.Parameters.(*DescribeResourcePermissionsInput) 2051 _ = input 2052 if !ok { 2053 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2054 } 2055 2056 opPath, opQuery := httpbinding.SplitURI("/api/v1/resources/{ResourceId}/permissions") 2057 request.URL.Path = opPath 2058 if len(request.URL.RawQuery) > 0 { 2059 request.URL.RawQuery = "&" + opQuery 2060 } else { 2061 request.URL.RawQuery = opQuery 2062 } 2063 2064 request.Method = "GET" 2065 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2066 if err != nil { 2067 return out, metadata, &smithy.SerializationError{Err: err} 2068 } 2069 2070 if err := awsRestjson1_serializeOpHttpBindingsDescribeResourcePermissionsInput(input, restEncoder); err != nil { 2071 return out, metadata, &smithy.SerializationError{Err: err} 2072 } 2073 2074 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2075 return out, metadata, &smithy.SerializationError{Err: err} 2076 } 2077 in.Request = request 2078 2079 return next.HandleSerialize(ctx, in) 2080} 2081func awsRestjson1_serializeOpHttpBindingsDescribeResourcePermissionsInput(v *DescribeResourcePermissionsInput, encoder *httpbinding.Encoder) error { 2082 if v == nil { 2083 return fmt.Errorf("unsupported serialization of nil %T", v) 2084 } 2085 2086 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 2087 locationName := "Authentication" 2088 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 2089 } 2090 2091 if v.Limit != nil { 2092 encoder.SetQuery("limit").Integer(*v.Limit) 2093 } 2094 2095 if v.Marker != nil { 2096 encoder.SetQuery("marker").String(*v.Marker) 2097 } 2098 2099 if v.PrincipalId != nil { 2100 encoder.SetQuery("principalId").String(*v.PrincipalId) 2101 } 2102 2103 if v.ResourceId == nil || len(*v.ResourceId) == 0 { 2104 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceId must not be empty")} 2105 } 2106 if v.ResourceId != nil { 2107 if err := encoder.SetURI("ResourceId").String(*v.ResourceId); err != nil { 2108 return err 2109 } 2110 } 2111 2112 return nil 2113} 2114 2115type awsRestjson1_serializeOpDescribeRootFolders struct { 2116} 2117 2118func (*awsRestjson1_serializeOpDescribeRootFolders) ID() string { 2119 return "OperationSerializer" 2120} 2121 2122func (m *awsRestjson1_serializeOpDescribeRootFolders) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2123 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2124) { 2125 request, ok := in.Request.(*smithyhttp.Request) 2126 if !ok { 2127 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2128 } 2129 2130 input, ok := in.Parameters.(*DescribeRootFoldersInput) 2131 _ = input 2132 if !ok { 2133 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2134 } 2135 2136 opPath, opQuery := httpbinding.SplitURI("/api/v1/me/root") 2137 request.URL.Path = opPath 2138 if len(request.URL.RawQuery) > 0 { 2139 request.URL.RawQuery = "&" + opQuery 2140 } else { 2141 request.URL.RawQuery = opQuery 2142 } 2143 2144 request.Method = "GET" 2145 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2146 if err != nil { 2147 return out, metadata, &smithy.SerializationError{Err: err} 2148 } 2149 2150 if err := awsRestjson1_serializeOpHttpBindingsDescribeRootFoldersInput(input, restEncoder); err != nil { 2151 return out, metadata, &smithy.SerializationError{Err: err} 2152 } 2153 2154 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2155 return out, metadata, &smithy.SerializationError{Err: err} 2156 } 2157 in.Request = request 2158 2159 return next.HandleSerialize(ctx, in) 2160} 2161func awsRestjson1_serializeOpHttpBindingsDescribeRootFoldersInput(v *DescribeRootFoldersInput, encoder *httpbinding.Encoder) error { 2162 if v == nil { 2163 return fmt.Errorf("unsupported serialization of nil %T", v) 2164 } 2165 2166 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 2167 locationName := "Authentication" 2168 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 2169 } 2170 2171 if v.Limit != nil { 2172 encoder.SetQuery("limit").Integer(*v.Limit) 2173 } 2174 2175 if v.Marker != nil { 2176 encoder.SetQuery("marker").String(*v.Marker) 2177 } 2178 2179 return nil 2180} 2181 2182type awsRestjson1_serializeOpDescribeUsers struct { 2183} 2184 2185func (*awsRestjson1_serializeOpDescribeUsers) ID() string { 2186 return "OperationSerializer" 2187} 2188 2189func (m *awsRestjson1_serializeOpDescribeUsers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2190 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2191) { 2192 request, ok := in.Request.(*smithyhttp.Request) 2193 if !ok { 2194 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2195 } 2196 2197 input, ok := in.Parameters.(*DescribeUsersInput) 2198 _ = input 2199 if !ok { 2200 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2201 } 2202 2203 opPath, opQuery := httpbinding.SplitURI("/api/v1/users") 2204 request.URL.Path = opPath 2205 if len(request.URL.RawQuery) > 0 { 2206 request.URL.RawQuery = "&" + opQuery 2207 } else { 2208 request.URL.RawQuery = opQuery 2209 } 2210 2211 request.Method = "GET" 2212 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2213 if err != nil { 2214 return out, metadata, &smithy.SerializationError{Err: err} 2215 } 2216 2217 if err := awsRestjson1_serializeOpHttpBindingsDescribeUsersInput(input, restEncoder); err != nil { 2218 return out, metadata, &smithy.SerializationError{Err: err} 2219 } 2220 2221 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2222 return out, metadata, &smithy.SerializationError{Err: err} 2223 } 2224 in.Request = request 2225 2226 return next.HandleSerialize(ctx, in) 2227} 2228func awsRestjson1_serializeOpHttpBindingsDescribeUsersInput(v *DescribeUsersInput, encoder *httpbinding.Encoder) error { 2229 if v == nil { 2230 return fmt.Errorf("unsupported serialization of nil %T", v) 2231 } 2232 2233 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 2234 locationName := "Authentication" 2235 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 2236 } 2237 2238 if v.Fields != nil { 2239 encoder.SetQuery("fields").String(*v.Fields) 2240 } 2241 2242 if len(v.Include) > 0 { 2243 encoder.SetQuery("include").String(string(v.Include)) 2244 } 2245 2246 if v.Limit != nil { 2247 encoder.SetQuery("limit").Integer(*v.Limit) 2248 } 2249 2250 if v.Marker != nil { 2251 encoder.SetQuery("marker").String(*v.Marker) 2252 } 2253 2254 if len(v.Order) > 0 { 2255 encoder.SetQuery("order").String(string(v.Order)) 2256 } 2257 2258 if v.OrganizationId != nil { 2259 encoder.SetQuery("organizationId").String(*v.OrganizationId) 2260 } 2261 2262 if v.Query != nil { 2263 encoder.SetQuery("query").String(*v.Query) 2264 } 2265 2266 if len(v.Sort) > 0 { 2267 encoder.SetQuery("sort").String(string(v.Sort)) 2268 } 2269 2270 if v.UserIds != nil { 2271 encoder.SetQuery("userIds").String(*v.UserIds) 2272 } 2273 2274 return nil 2275} 2276 2277type awsRestjson1_serializeOpGetCurrentUser struct { 2278} 2279 2280func (*awsRestjson1_serializeOpGetCurrentUser) ID() string { 2281 return "OperationSerializer" 2282} 2283 2284func (m *awsRestjson1_serializeOpGetCurrentUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2285 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2286) { 2287 request, ok := in.Request.(*smithyhttp.Request) 2288 if !ok { 2289 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2290 } 2291 2292 input, ok := in.Parameters.(*GetCurrentUserInput) 2293 _ = input 2294 if !ok { 2295 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2296 } 2297 2298 opPath, opQuery := httpbinding.SplitURI("/api/v1/me") 2299 request.URL.Path = opPath 2300 if len(request.URL.RawQuery) > 0 { 2301 request.URL.RawQuery = "&" + opQuery 2302 } else { 2303 request.URL.RawQuery = opQuery 2304 } 2305 2306 request.Method = "GET" 2307 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2308 if err != nil { 2309 return out, metadata, &smithy.SerializationError{Err: err} 2310 } 2311 2312 if err := awsRestjson1_serializeOpHttpBindingsGetCurrentUserInput(input, restEncoder); err != nil { 2313 return out, metadata, &smithy.SerializationError{Err: err} 2314 } 2315 2316 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2317 return out, metadata, &smithy.SerializationError{Err: err} 2318 } 2319 in.Request = request 2320 2321 return next.HandleSerialize(ctx, in) 2322} 2323func awsRestjson1_serializeOpHttpBindingsGetCurrentUserInput(v *GetCurrentUserInput, encoder *httpbinding.Encoder) error { 2324 if v == nil { 2325 return fmt.Errorf("unsupported serialization of nil %T", v) 2326 } 2327 2328 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 2329 locationName := "Authentication" 2330 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 2331 } 2332 2333 return nil 2334} 2335 2336type awsRestjson1_serializeOpGetDocument struct { 2337} 2338 2339func (*awsRestjson1_serializeOpGetDocument) ID() string { 2340 return "OperationSerializer" 2341} 2342 2343func (m *awsRestjson1_serializeOpGetDocument) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2344 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2345) { 2346 request, ok := in.Request.(*smithyhttp.Request) 2347 if !ok { 2348 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2349 } 2350 2351 input, ok := in.Parameters.(*GetDocumentInput) 2352 _ = input 2353 if !ok { 2354 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2355 } 2356 2357 opPath, opQuery := httpbinding.SplitURI("/api/v1/documents/{DocumentId}") 2358 request.URL.Path = opPath 2359 if len(request.URL.RawQuery) > 0 { 2360 request.URL.RawQuery = "&" + opQuery 2361 } else { 2362 request.URL.RawQuery = opQuery 2363 } 2364 2365 request.Method = "GET" 2366 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2367 if err != nil { 2368 return out, metadata, &smithy.SerializationError{Err: err} 2369 } 2370 2371 if err := awsRestjson1_serializeOpHttpBindingsGetDocumentInput(input, restEncoder); err != nil { 2372 return out, metadata, &smithy.SerializationError{Err: err} 2373 } 2374 2375 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2376 return out, metadata, &smithy.SerializationError{Err: err} 2377 } 2378 in.Request = request 2379 2380 return next.HandleSerialize(ctx, in) 2381} 2382func awsRestjson1_serializeOpHttpBindingsGetDocumentInput(v *GetDocumentInput, encoder *httpbinding.Encoder) error { 2383 if v == nil { 2384 return fmt.Errorf("unsupported serialization of nil %T", v) 2385 } 2386 2387 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 2388 locationName := "Authentication" 2389 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 2390 } 2391 2392 if v.DocumentId == nil || len(*v.DocumentId) == 0 { 2393 return &smithy.SerializationError{Err: fmt.Errorf("input member DocumentId must not be empty")} 2394 } 2395 if v.DocumentId != nil { 2396 if err := encoder.SetURI("DocumentId").String(*v.DocumentId); err != nil { 2397 return err 2398 } 2399 } 2400 2401 if v.IncludeCustomMetadata { 2402 encoder.SetQuery("includeCustomMetadata").Boolean(v.IncludeCustomMetadata) 2403 } 2404 2405 return nil 2406} 2407 2408type awsRestjson1_serializeOpGetDocumentPath struct { 2409} 2410 2411func (*awsRestjson1_serializeOpGetDocumentPath) ID() string { 2412 return "OperationSerializer" 2413} 2414 2415func (m *awsRestjson1_serializeOpGetDocumentPath) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2416 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2417) { 2418 request, ok := in.Request.(*smithyhttp.Request) 2419 if !ok { 2420 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2421 } 2422 2423 input, ok := in.Parameters.(*GetDocumentPathInput) 2424 _ = input 2425 if !ok { 2426 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2427 } 2428 2429 opPath, opQuery := httpbinding.SplitURI("/api/v1/documents/{DocumentId}/path") 2430 request.URL.Path = opPath 2431 if len(request.URL.RawQuery) > 0 { 2432 request.URL.RawQuery = "&" + opQuery 2433 } else { 2434 request.URL.RawQuery = opQuery 2435 } 2436 2437 request.Method = "GET" 2438 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2439 if err != nil { 2440 return out, metadata, &smithy.SerializationError{Err: err} 2441 } 2442 2443 if err := awsRestjson1_serializeOpHttpBindingsGetDocumentPathInput(input, restEncoder); err != nil { 2444 return out, metadata, &smithy.SerializationError{Err: err} 2445 } 2446 2447 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2448 return out, metadata, &smithy.SerializationError{Err: err} 2449 } 2450 in.Request = request 2451 2452 return next.HandleSerialize(ctx, in) 2453} 2454func awsRestjson1_serializeOpHttpBindingsGetDocumentPathInput(v *GetDocumentPathInput, encoder *httpbinding.Encoder) error { 2455 if v == nil { 2456 return fmt.Errorf("unsupported serialization of nil %T", v) 2457 } 2458 2459 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 2460 locationName := "Authentication" 2461 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 2462 } 2463 2464 if v.DocumentId == nil || len(*v.DocumentId) == 0 { 2465 return &smithy.SerializationError{Err: fmt.Errorf("input member DocumentId must not be empty")} 2466 } 2467 if v.DocumentId != nil { 2468 if err := encoder.SetURI("DocumentId").String(*v.DocumentId); err != nil { 2469 return err 2470 } 2471 } 2472 2473 if v.Fields != nil { 2474 encoder.SetQuery("fields").String(*v.Fields) 2475 } 2476 2477 if v.Limit != nil { 2478 encoder.SetQuery("limit").Integer(*v.Limit) 2479 } 2480 2481 if v.Marker != nil { 2482 encoder.SetQuery("marker").String(*v.Marker) 2483 } 2484 2485 return nil 2486} 2487 2488type awsRestjson1_serializeOpGetDocumentVersion struct { 2489} 2490 2491func (*awsRestjson1_serializeOpGetDocumentVersion) ID() string { 2492 return "OperationSerializer" 2493} 2494 2495func (m *awsRestjson1_serializeOpGetDocumentVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2496 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2497) { 2498 request, ok := in.Request.(*smithyhttp.Request) 2499 if !ok { 2500 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2501 } 2502 2503 input, ok := in.Parameters.(*GetDocumentVersionInput) 2504 _ = input 2505 if !ok { 2506 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2507 } 2508 2509 opPath, opQuery := httpbinding.SplitURI("/api/v1/documents/{DocumentId}/versions/{VersionId}") 2510 request.URL.Path = opPath 2511 if len(request.URL.RawQuery) > 0 { 2512 request.URL.RawQuery = "&" + opQuery 2513 } else { 2514 request.URL.RawQuery = opQuery 2515 } 2516 2517 request.Method = "GET" 2518 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2519 if err != nil { 2520 return out, metadata, &smithy.SerializationError{Err: err} 2521 } 2522 2523 if err := awsRestjson1_serializeOpHttpBindingsGetDocumentVersionInput(input, restEncoder); err != nil { 2524 return out, metadata, &smithy.SerializationError{Err: err} 2525 } 2526 2527 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2528 return out, metadata, &smithy.SerializationError{Err: err} 2529 } 2530 in.Request = request 2531 2532 return next.HandleSerialize(ctx, in) 2533} 2534func awsRestjson1_serializeOpHttpBindingsGetDocumentVersionInput(v *GetDocumentVersionInput, encoder *httpbinding.Encoder) error { 2535 if v == nil { 2536 return fmt.Errorf("unsupported serialization of nil %T", v) 2537 } 2538 2539 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 2540 locationName := "Authentication" 2541 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 2542 } 2543 2544 if v.DocumentId == nil || len(*v.DocumentId) == 0 { 2545 return &smithy.SerializationError{Err: fmt.Errorf("input member DocumentId must not be empty")} 2546 } 2547 if v.DocumentId != nil { 2548 if err := encoder.SetURI("DocumentId").String(*v.DocumentId); err != nil { 2549 return err 2550 } 2551 } 2552 2553 if v.Fields != nil { 2554 encoder.SetQuery("fields").String(*v.Fields) 2555 } 2556 2557 if v.IncludeCustomMetadata { 2558 encoder.SetQuery("includeCustomMetadata").Boolean(v.IncludeCustomMetadata) 2559 } 2560 2561 if v.VersionId == nil || len(*v.VersionId) == 0 { 2562 return &smithy.SerializationError{Err: fmt.Errorf("input member VersionId must not be empty")} 2563 } 2564 if v.VersionId != nil { 2565 if err := encoder.SetURI("VersionId").String(*v.VersionId); err != nil { 2566 return err 2567 } 2568 } 2569 2570 return nil 2571} 2572 2573type awsRestjson1_serializeOpGetFolder struct { 2574} 2575 2576func (*awsRestjson1_serializeOpGetFolder) ID() string { 2577 return "OperationSerializer" 2578} 2579 2580func (m *awsRestjson1_serializeOpGetFolder) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2581 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2582) { 2583 request, ok := in.Request.(*smithyhttp.Request) 2584 if !ok { 2585 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2586 } 2587 2588 input, ok := in.Parameters.(*GetFolderInput) 2589 _ = input 2590 if !ok { 2591 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2592 } 2593 2594 opPath, opQuery := httpbinding.SplitURI("/api/v1/folders/{FolderId}") 2595 request.URL.Path = opPath 2596 if len(request.URL.RawQuery) > 0 { 2597 request.URL.RawQuery = "&" + opQuery 2598 } else { 2599 request.URL.RawQuery = opQuery 2600 } 2601 2602 request.Method = "GET" 2603 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2604 if err != nil { 2605 return out, metadata, &smithy.SerializationError{Err: err} 2606 } 2607 2608 if err := awsRestjson1_serializeOpHttpBindingsGetFolderInput(input, restEncoder); err != nil { 2609 return out, metadata, &smithy.SerializationError{Err: err} 2610 } 2611 2612 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2613 return out, metadata, &smithy.SerializationError{Err: err} 2614 } 2615 in.Request = request 2616 2617 return next.HandleSerialize(ctx, in) 2618} 2619func awsRestjson1_serializeOpHttpBindingsGetFolderInput(v *GetFolderInput, encoder *httpbinding.Encoder) error { 2620 if v == nil { 2621 return fmt.Errorf("unsupported serialization of nil %T", v) 2622 } 2623 2624 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 2625 locationName := "Authentication" 2626 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 2627 } 2628 2629 if v.FolderId == nil || len(*v.FolderId) == 0 { 2630 return &smithy.SerializationError{Err: fmt.Errorf("input member FolderId must not be empty")} 2631 } 2632 if v.FolderId != nil { 2633 if err := encoder.SetURI("FolderId").String(*v.FolderId); err != nil { 2634 return err 2635 } 2636 } 2637 2638 if v.IncludeCustomMetadata { 2639 encoder.SetQuery("includeCustomMetadata").Boolean(v.IncludeCustomMetadata) 2640 } 2641 2642 return nil 2643} 2644 2645type awsRestjson1_serializeOpGetFolderPath struct { 2646} 2647 2648func (*awsRestjson1_serializeOpGetFolderPath) ID() string { 2649 return "OperationSerializer" 2650} 2651 2652func (m *awsRestjson1_serializeOpGetFolderPath) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2653 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2654) { 2655 request, ok := in.Request.(*smithyhttp.Request) 2656 if !ok { 2657 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2658 } 2659 2660 input, ok := in.Parameters.(*GetFolderPathInput) 2661 _ = input 2662 if !ok { 2663 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2664 } 2665 2666 opPath, opQuery := httpbinding.SplitURI("/api/v1/folders/{FolderId}/path") 2667 request.URL.Path = opPath 2668 if len(request.URL.RawQuery) > 0 { 2669 request.URL.RawQuery = "&" + opQuery 2670 } else { 2671 request.URL.RawQuery = opQuery 2672 } 2673 2674 request.Method = "GET" 2675 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2676 if err != nil { 2677 return out, metadata, &smithy.SerializationError{Err: err} 2678 } 2679 2680 if err := awsRestjson1_serializeOpHttpBindingsGetFolderPathInput(input, restEncoder); err != nil { 2681 return out, metadata, &smithy.SerializationError{Err: err} 2682 } 2683 2684 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2685 return out, metadata, &smithy.SerializationError{Err: err} 2686 } 2687 in.Request = request 2688 2689 return next.HandleSerialize(ctx, in) 2690} 2691func awsRestjson1_serializeOpHttpBindingsGetFolderPathInput(v *GetFolderPathInput, encoder *httpbinding.Encoder) error { 2692 if v == nil { 2693 return fmt.Errorf("unsupported serialization of nil %T", v) 2694 } 2695 2696 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 2697 locationName := "Authentication" 2698 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 2699 } 2700 2701 if v.Fields != nil { 2702 encoder.SetQuery("fields").String(*v.Fields) 2703 } 2704 2705 if v.FolderId == nil || len(*v.FolderId) == 0 { 2706 return &smithy.SerializationError{Err: fmt.Errorf("input member FolderId must not be empty")} 2707 } 2708 if v.FolderId != nil { 2709 if err := encoder.SetURI("FolderId").String(*v.FolderId); err != nil { 2710 return err 2711 } 2712 } 2713 2714 if v.Limit != nil { 2715 encoder.SetQuery("limit").Integer(*v.Limit) 2716 } 2717 2718 if v.Marker != nil { 2719 encoder.SetQuery("marker").String(*v.Marker) 2720 } 2721 2722 return nil 2723} 2724 2725type awsRestjson1_serializeOpGetResources struct { 2726} 2727 2728func (*awsRestjson1_serializeOpGetResources) ID() string { 2729 return "OperationSerializer" 2730} 2731 2732func (m *awsRestjson1_serializeOpGetResources) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2733 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2734) { 2735 request, ok := in.Request.(*smithyhttp.Request) 2736 if !ok { 2737 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2738 } 2739 2740 input, ok := in.Parameters.(*GetResourcesInput) 2741 _ = input 2742 if !ok { 2743 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2744 } 2745 2746 opPath, opQuery := httpbinding.SplitURI("/api/v1/resources") 2747 request.URL.Path = opPath 2748 if len(request.URL.RawQuery) > 0 { 2749 request.URL.RawQuery = "&" + opQuery 2750 } else { 2751 request.URL.RawQuery = opQuery 2752 } 2753 2754 request.Method = "GET" 2755 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2756 if err != nil { 2757 return out, metadata, &smithy.SerializationError{Err: err} 2758 } 2759 2760 if err := awsRestjson1_serializeOpHttpBindingsGetResourcesInput(input, restEncoder); err != nil { 2761 return out, metadata, &smithy.SerializationError{Err: err} 2762 } 2763 2764 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2765 return out, metadata, &smithy.SerializationError{Err: err} 2766 } 2767 in.Request = request 2768 2769 return next.HandleSerialize(ctx, in) 2770} 2771func awsRestjson1_serializeOpHttpBindingsGetResourcesInput(v *GetResourcesInput, encoder *httpbinding.Encoder) error { 2772 if v == nil { 2773 return fmt.Errorf("unsupported serialization of nil %T", v) 2774 } 2775 2776 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 2777 locationName := "Authentication" 2778 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 2779 } 2780 2781 if len(v.CollectionType) > 0 { 2782 encoder.SetQuery("collectionType").String(string(v.CollectionType)) 2783 } 2784 2785 if v.Limit != nil { 2786 encoder.SetQuery("limit").Integer(*v.Limit) 2787 } 2788 2789 if v.Marker != nil { 2790 encoder.SetQuery("marker").String(*v.Marker) 2791 } 2792 2793 if v.UserId != nil { 2794 encoder.SetQuery("userId").String(*v.UserId) 2795 } 2796 2797 return nil 2798} 2799 2800type awsRestjson1_serializeOpInitiateDocumentVersionUpload struct { 2801} 2802 2803func (*awsRestjson1_serializeOpInitiateDocumentVersionUpload) ID() string { 2804 return "OperationSerializer" 2805} 2806 2807func (m *awsRestjson1_serializeOpInitiateDocumentVersionUpload) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2808 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2809) { 2810 request, ok := in.Request.(*smithyhttp.Request) 2811 if !ok { 2812 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2813 } 2814 2815 input, ok := in.Parameters.(*InitiateDocumentVersionUploadInput) 2816 _ = input 2817 if !ok { 2818 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2819 } 2820 2821 opPath, opQuery := httpbinding.SplitURI("/api/v1/documents") 2822 request.URL.Path = opPath 2823 if len(request.URL.RawQuery) > 0 { 2824 request.URL.RawQuery = "&" + opQuery 2825 } else { 2826 request.URL.RawQuery = opQuery 2827 } 2828 2829 request.Method = "POST" 2830 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2831 if err != nil { 2832 return out, metadata, &smithy.SerializationError{Err: err} 2833 } 2834 2835 if err := awsRestjson1_serializeOpHttpBindingsInitiateDocumentVersionUploadInput(input, restEncoder); err != nil { 2836 return out, metadata, &smithy.SerializationError{Err: err} 2837 } 2838 2839 restEncoder.SetHeader("Content-Type").String("application/json") 2840 2841 jsonEncoder := smithyjson.NewEncoder() 2842 if err := awsRestjson1_serializeOpDocumentInitiateDocumentVersionUploadInput(input, jsonEncoder.Value); err != nil { 2843 return out, metadata, &smithy.SerializationError{Err: err} 2844 } 2845 2846 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2847 return out, metadata, &smithy.SerializationError{Err: err} 2848 } 2849 2850 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2851 return out, metadata, &smithy.SerializationError{Err: err} 2852 } 2853 in.Request = request 2854 2855 return next.HandleSerialize(ctx, in) 2856} 2857func awsRestjson1_serializeOpHttpBindingsInitiateDocumentVersionUploadInput(v *InitiateDocumentVersionUploadInput, encoder *httpbinding.Encoder) error { 2858 if v == nil { 2859 return fmt.Errorf("unsupported serialization of nil %T", v) 2860 } 2861 2862 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 2863 locationName := "Authentication" 2864 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 2865 } 2866 2867 return nil 2868} 2869 2870func awsRestjson1_serializeOpDocumentInitiateDocumentVersionUploadInput(v *InitiateDocumentVersionUploadInput, value smithyjson.Value) error { 2871 object := value.Object() 2872 defer object.Close() 2873 2874 if v.ContentCreatedTimestamp != nil { 2875 ok := object.Key("ContentCreatedTimestamp") 2876 ok.Double(smithytime.FormatEpochSeconds(*v.ContentCreatedTimestamp)) 2877 } 2878 2879 if v.ContentModifiedTimestamp != nil { 2880 ok := object.Key("ContentModifiedTimestamp") 2881 ok.Double(smithytime.FormatEpochSeconds(*v.ContentModifiedTimestamp)) 2882 } 2883 2884 if v.ContentType != nil { 2885 ok := object.Key("ContentType") 2886 ok.String(*v.ContentType) 2887 } 2888 2889 if v.DocumentSizeInBytes != nil { 2890 ok := object.Key("DocumentSizeInBytes") 2891 ok.Long(*v.DocumentSizeInBytes) 2892 } 2893 2894 if v.Id != nil { 2895 ok := object.Key("Id") 2896 ok.String(*v.Id) 2897 } 2898 2899 if v.Name != nil { 2900 ok := object.Key("Name") 2901 ok.String(*v.Name) 2902 } 2903 2904 if v.ParentFolderId != nil { 2905 ok := object.Key("ParentFolderId") 2906 ok.String(*v.ParentFolderId) 2907 } 2908 2909 return nil 2910} 2911 2912type awsRestjson1_serializeOpRemoveAllResourcePermissions struct { 2913} 2914 2915func (*awsRestjson1_serializeOpRemoveAllResourcePermissions) ID() string { 2916 return "OperationSerializer" 2917} 2918 2919func (m *awsRestjson1_serializeOpRemoveAllResourcePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2920 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2921) { 2922 request, ok := in.Request.(*smithyhttp.Request) 2923 if !ok { 2924 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2925 } 2926 2927 input, ok := in.Parameters.(*RemoveAllResourcePermissionsInput) 2928 _ = input 2929 if !ok { 2930 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2931 } 2932 2933 opPath, opQuery := httpbinding.SplitURI("/api/v1/resources/{ResourceId}/permissions") 2934 request.URL.Path = opPath 2935 if len(request.URL.RawQuery) > 0 { 2936 request.URL.RawQuery = "&" + opQuery 2937 } else { 2938 request.URL.RawQuery = opQuery 2939 } 2940 2941 request.Method = "DELETE" 2942 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2943 if err != nil { 2944 return out, metadata, &smithy.SerializationError{Err: err} 2945 } 2946 2947 if err := awsRestjson1_serializeOpHttpBindingsRemoveAllResourcePermissionsInput(input, restEncoder); err != nil { 2948 return out, metadata, &smithy.SerializationError{Err: err} 2949 } 2950 2951 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2952 return out, metadata, &smithy.SerializationError{Err: err} 2953 } 2954 in.Request = request 2955 2956 return next.HandleSerialize(ctx, in) 2957} 2958func awsRestjson1_serializeOpHttpBindingsRemoveAllResourcePermissionsInput(v *RemoveAllResourcePermissionsInput, encoder *httpbinding.Encoder) error { 2959 if v == nil { 2960 return fmt.Errorf("unsupported serialization of nil %T", v) 2961 } 2962 2963 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 2964 locationName := "Authentication" 2965 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 2966 } 2967 2968 if v.ResourceId == nil || len(*v.ResourceId) == 0 { 2969 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceId must not be empty")} 2970 } 2971 if v.ResourceId != nil { 2972 if err := encoder.SetURI("ResourceId").String(*v.ResourceId); err != nil { 2973 return err 2974 } 2975 } 2976 2977 return nil 2978} 2979 2980type awsRestjson1_serializeOpRemoveResourcePermission struct { 2981} 2982 2983func (*awsRestjson1_serializeOpRemoveResourcePermission) ID() string { 2984 return "OperationSerializer" 2985} 2986 2987func (m *awsRestjson1_serializeOpRemoveResourcePermission) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2988 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2989) { 2990 request, ok := in.Request.(*smithyhttp.Request) 2991 if !ok { 2992 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2993 } 2994 2995 input, ok := in.Parameters.(*RemoveResourcePermissionInput) 2996 _ = input 2997 if !ok { 2998 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2999 } 3000 3001 opPath, opQuery := httpbinding.SplitURI("/api/v1/resources/{ResourceId}/permissions/{PrincipalId}") 3002 request.URL.Path = opPath 3003 if len(request.URL.RawQuery) > 0 { 3004 request.URL.RawQuery = "&" + opQuery 3005 } else { 3006 request.URL.RawQuery = opQuery 3007 } 3008 3009 request.Method = "DELETE" 3010 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3011 if err != nil { 3012 return out, metadata, &smithy.SerializationError{Err: err} 3013 } 3014 3015 if err := awsRestjson1_serializeOpHttpBindingsRemoveResourcePermissionInput(input, restEncoder); err != nil { 3016 return out, metadata, &smithy.SerializationError{Err: err} 3017 } 3018 3019 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3020 return out, metadata, &smithy.SerializationError{Err: err} 3021 } 3022 in.Request = request 3023 3024 return next.HandleSerialize(ctx, in) 3025} 3026func awsRestjson1_serializeOpHttpBindingsRemoveResourcePermissionInput(v *RemoveResourcePermissionInput, encoder *httpbinding.Encoder) error { 3027 if v == nil { 3028 return fmt.Errorf("unsupported serialization of nil %T", v) 3029 } 3030 3031 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 3032 locationName := "Authentication" 3033 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 3034 } 3035 3036 if v.PrincipalId == nil || len(*v.PrincipalId) == 0 { 3037 return &smithy.SerializationError{Err: fmt.Errorf("input member PrincipalId must not be empty")} 3038 } 3039 if v.PrincipalId != nil { 3040 if err := encoder.SetURI("PrincipalId").String(*v.PrincipalId); err != nil { 3041 return err 3042 } 3043 } 3044 3045 if len(v.PrincipalType) > 0 { 3046 encoder.SetQuery("type").String(string(v.PrincipalType)) 3047 } 3048 3049 if v.ResourceId == nil || len(*v.ResourceId) == 0 { 3050 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceId must not be empty")} 3051 } 3052 if v.ResourceId != nil { 3053 if err := encoder.SetURI("ResourceId").String(*v.ResourceId); err != nil { 3054 return err 3055 } 3056 } 3057 3058 return nil 3059} 3060 3061type awsRestjson1_serializeOpUpdateDocument struct { 3062} 3063 3064func (*awsRestjson1_serializeOpUpdateDocument) ID() string { 3065 return "OperationSerializer" 3066} 3067 3068func (m *awsRestjson1_serializeOpUpdateDocument) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3069 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3070) { 3071 request, ok := in.Request.(*smithyhttp.Request) 3072 if !ok { 3073 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3074 } 3075 3076 input, ok := in.Parameters.(*UpdateDocumentInput) 3077 _ = input 3078 if !ok { 3079 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3080 } 3081 3082 opPath, opQuery := httpbinding.SplitURI("/api/v1/documents/{DocumentId}") 3083 request.URL.Path = opPath 3084 if len(request.URL.RawQuery) > 0 { 3085 request.URL.RawQuery = "&" + opQuery 3086 } else { 3087 request.URL.RawQuery = opQuery 3088 } 3089 3090 request.Method = "PATCH" 3091 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3092 if err != nil { 3093 return out, metadata, &smithy.SerializationError{Err: err} 3094 } 3095 3096 if err := awsRestjson1_serializeOpHttpBindingsUpdateDocumentInput(input, restEncoder); err != nil { 3097 return out, metadata, &smithy.SerializationError{Err: err} 3098 } 3099 3100 restEncoder.SetHeader("Content-Type").String("application/json") 3101 3102 jsonEncoder := smithyjson.NewEncoder() 3103 if err := awsRestjson1_serializeOpDocumentUpdateDocumentInput(input, jsonEncoder.Value); err != nil { 3104 return out, metadata, &smithy.SerializationError{Err: err} 3105 } 3106 3107 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3108 return out, metadata, &smithy.SerializationError{Err: err} 3109 } 3110 3111 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3112 return out, metadata, &smithy.SerializationError{Err: err} 3113 } 3114 in.Request = request 3115 3116 return next.HandleSerialize(ctx, in) 3117} 3118func awsRestjson1_serializeOpHttpBindingsUpdateDocumentInput(v *UpdateDocumentInput, encoder *httpbinding.Encoder) error { 3119 if v == nil { 3120 return fmt.Errorf("unsupported serialization of nil %T", v) 3121 } 3122 3123 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 3124 locationName := "Authentication" 3125 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 3126 } 3127 3128 if v.DocumentId == nil || len(*v.DocumentId) == 0 { 3129 return &smithy.SerializationError{Err: fmt.Errorf("input member DocumentId must not be empty")} 3130 } 3131 if v.DocumentId != nil { 3132 if err := encoder.SetURI("DocumentId").String(*v.DocumentId); err != nil { 3133 return err 3134 } 3135 } 3136 3137 return nil 3138} 3139 3140func awsRestjson1_serializeOpDocumentUpdateDocumentInput(v *UpdateDocumentInput, value smithyjson.Value) error { 3141 object := value.Object() 3142 defer object.Close() 3143 3144 if v.Name != nil { 3145 ok := object.Key("Name") 3146 ok.String(*v.Name) 3147 } 3148 3149 if v.ParentFolderId != nil { 3150 ok := object.Key("ParentFolderId") 3151 ok.String(*v.ParentFolderId) 3152 } 3153 3154 if len(v.ResourceState) > 0 { 3155 ok := object.Key("ResourceState") 3156 ok.String(string(v.ResourceState)) 3157 } 3158 3159 return nil 3160} 3161 3162type awsRestjson1_serializeOpUpdateDocumentVersion struct { 3163} 3164 3165func (*awsRestjson1_serializeOpUpdateDocumentVersion) ID() string { 3166 return "OperationSerializer" 3167} 3168 3169func (m *awsRestjson1_serializeOpUpdateDocumentVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3170 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3171) { 3172 request, ok := in.Request.(*smithyhttp.Request) 3173 if !ok { 3174 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3175 } 3176 3177 input, ok := in.Parameters.(*UpdateDocumentVersionInput) 3178 _ = input 3179 if !ok { 3180 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3181 } 3182 3183 opPath, opQuery := httpbinding.SplitURI("/api/v1/documents/{DocumentId}/versions/{VersionId}") 3184 request.URL.Path = opPath 3185 if len(request.URL.RawQuery) > 0 { 3186 request.URL.RawQuery = "&" + opQuery 3187 } else { 3188 request.URL.RawQuery = opQuery 3189 } 3190 3191 request.Method = "PATCH" 3192 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3193 if err != nil { 3194 return out, metadata, &smithy.SerializationError{Err: err} 3195 } 3196 3197 if err := awsRestjson1_serializeOpHttpBindingsUpdateDocumentVersionInput(input, restEncoder); err != nil { 3198 return out, metadata, &smithy.SerializationError{Err: err} 3199 } 3200 3201 restEncoder.SetHeader("Content-Type").String("application/json") 3202 3203 jsonEncoder := smithyjson.NewEncoder() 3204 if err := awsRestjson1_serializeOpDocumentUpdateDocumentVersionInput(input, jsonEncoder.Value); err != nil { 3205 return out, metadata, &smithy.SerializationError{Err: err} 3206 } 3207 3208 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3209 return out, metadata, &smithy.SerializationError{Err: err} 3210 } 3211 3212 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3213 return out, metadata, &smithy.SerializationError{Err: err} 3214 } 3215 in.Request = request 3216 3217 return next.HandleSerialize(ctx, in) 3218} 3219func awsRestjson1_serializeOpHttpBindingsUpdateDocumentVersionInput(v *UpdateDocumentVersionInput, encoder *httpbinding.Encoder) error { 3220 if v == nil { 3221 return fmt.Errorf("unsupported serialization of nil %T", v) 3222 } 3223 3224 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 3225 locationName := "Authentication" 3226 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 3227 } 3228 3229 if v.DocumentId == nil || len(*v.DocumentId) == 0 { 3230 return &smithy.SerializationError{Err: fmt.Errorf("input member DocumentId must not be empty")} 3231 } 3232 if v.DocumentId != nil { 3233 if err := encoder.SetURI("DocumentId").String(*v.DocumentId); err != nil { 3234 return err 3235 } 3236 } 3237 3238 if v.VersionId == nil || len(*v.VersionId) == 0 { 3239 return &smithy.SerializationError{Err: fmt.Errorf("input member VersionId must not be empty")} 3240 } 3241 if v.VersionId != nil { 3242 if err := encoder.SetURI("VersionId").String(*v.VersionId); err != nil { 3243 return err 3244 } 3245 } 3246 3247 return nil 3248} 3249 3250func awsRestjson1_serializeOpDocumentUpdateDocumentVersionInput(v *UpdateDocumentVersionInput, value smithyjson.Value) error { 3251 object := value.Object() 3252 defer object.Close() 3253 3254 if len(v.VersionStatus) > 0 { 3255 ok := object.Key("VersionStatus") 3256 ok.String(string(v.VersionStatus)) 3257 } 3258 3259 return nil 3260} 3261 3262type awsRestjson1_serializeOpUpdateFolder struct { 3263} 3264 3265func (*awsRestjson1_serializeOpUpdateFolder) ID() string { 3266 return "OperationSerializer" 3267} 3268 3269func (m *awsRestjson1_serializeOpUpdateFolder) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3270 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3271) { 3272 request, ok := in.Request.(*smithyhttp.Request) 3273 if !ok { 3274 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3275 } 3276 3277 input, ok := in.Parameters.(*UpdateFolderInput) 3278 _ = input 3279 if !ok { 3280 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3281 } 3282 3283 opPath, opQuery := httpbinding.SplitURI("/api/v1/folders/{FolderId}") 3284 request.URL.Path = opPath 3285 if len(request.URL.RawQuery) > 0 { 3286 request.URL.RawQuery = "&" + opQuery 3287 } else { 3288 request.URL.RawQuery = opQuery 3289 } 3290 3291 request.Method = "PATCH" 3292 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3293 if err != nil { 3294 return out, metadata, &smithy.SerializationError{Err: err} 3295 } 3296 3297 if err := awsRestjson1_serializeOpHttpBindingsUpdateFolderInput(input, restEncoder); err != nil { 3298 return out, metadata, &smithy.SerializationError{Err: err} 3299 } 3300 3301 restEncoder.SetHeader("Content-Type").String("application/json") 3302 3303 jsonEncoder := smithyjson.NewEncoder() 3304 if err := awsRestjson1_serializeOpDocumentUpdateFolderInput(input, jsonEncoder.Value); err != nil { 3305 return out, metadata, &smithy.SerializationError{Err: err} 3306 } 3307 3308 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3309 return out, metadata, &smithy.SerializationError{Err: err} 3310 } 3311 3312 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3313 return out, metadata, &smithy.SerializationError{Err: err} 3314 } 3315 in.Request = request 3316 3317 return next.HandleSerialize(ctx, in) 3318} 3319func awsRestjson1_serializeOpHttpBindingsUpdateFolderInput(v *UpdateFolderInput, encoder *httpbinding.Encoder) error { 3320 if v == nil { 3321 return fmt.Errorf("unsupported serialization of nil %T", v) 3322 } 3323 3324 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 3325 locationName := "Authentication" 3326 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 3327 } 3328 3329 if v.FolderId == nil || len(*v.FolderId) == 0 { 3330 return &smithy.SerializationError{Err: fmt.Errorf("input member FolderId must not be empty")} 3331 } 3332 if v.FolderId != nil { 3333 if err := encoder.SetURI("FolderId").String(*v.FolderId); err != nil { 3334 return err 3335 } 3336 } 3337 3338 return nil 3339} 3340 3341func awsRestjson1_serializeOpDocumentUpdateFolderInput(v *UpdateFolderInput, value smithyjson.Value) error { 3342 object := value.Object() 3343 defer object.Close() 3344 3345 if v.Name != nil { 3346 ok := object.Key("Name") 3347 ok.String(*v.Name) 3348 } 3349 3350 if v.ParentFolderId != nil { 3351 ok := object.Key("ParentFolderId") 3352 ok.String(*v.ParentFolderId) 3353 } 3354 3355 if len(v.ResourceState) > 0 { 3356 ok := object.Key("ResourceState") 3357 ok.String(string(v.ResourceState)) 3358 } 3359 3360 return nil 3361} 3362 3363type awsRestjson1_serializeOpUpdateUser struct { 3364} 3365 3366func (*awsRestjson1_serializeOpUpdateUser) ID() string { 3367 return "OperationSerializer" 3368} 3369 3370func (m *awsRestjson1_serializeOpUpdateUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3371 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3372) { 3373 request, ok := in.Request.(*smithyhttp.Request) 3374 if !ok { 3375 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3376 } 3377 3378 input, ok := in.Parameters.(*UpdateUserInput) 3379 _ = input 3380 if !ok { 3381 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3382 } 3383 3384 opPath, opQuery := httpbinding.SplitURI("/api/v1/users/{UserId}") 3385 request.URL.Path = opPath 3386 if len(request.URL.RawQuery) > 0 { 3387 request.URL.RawQuery = "&" + opQuery 3388 } else { 3389 request.URL.RawQuery = opQuery 3390 } 3391 3392 request.Method = "PATCH" 3393 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3394 if err != nil { 3395 return out, metadata, &smithy.SerializationError{Err: err} 3396 } 3397 3398 if err := awsRestjson1_serializeOpHttpBindingsUpdateUserInput(input, restEncoder); err != nil { 3399 return out, metadata, &smithy.SerializationError{Err: err} 3400 } 3401 3402 restEncoder.SetHeader("Content-Type").String("application/json") 3403 3404 jsonEncoder := smithyjson.NewEncoder() 3405 if err := awsRestjson1_serializeOpDocumentUpdateUserInput(input, jsonEncoder.Value); err != nil { 3406 return out, metadata, &smithy.SerializationError{Err: err} 3407 } 3408 3409 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3410 return out, metadata, &smithy.SerializationError{Err: err} 3411 } 3412 3413 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3414 return out, metadata, &smithy.SerializationError{Err: err} 3415 } 3416 in.Request = request 3417 3418 return next.HandleSerialize(ctx, in) 3419} 3420func awsRestjson1_serializeOpHttpBindingsUpdateUserInput(v *UpdateUserInput, encoder *httpbinding.Encoder) error { 3421 if v == nil { 3422 return fmt.Errorf("unsupported serialization of nil %T", v) 3423 } 3424 3425 if v.AuthenticationToken != nil && len(*v.AuthenticationToken) > 0 { 3426 locationName := "Authentication" 3427 encoder.SetHeader(locationName).String(*v.AuthenticationToken) 3428 } 3429 3430 if v.UserId == nil || len(*v.UserId) == 0 { 3431 return &smithy.SerializationError{Err: fmt.Errorf("input member UserId must not be empty")} 3432 } 3433 if v.UserId != nil { 3434 if err := encoder.SetURI("UserId").String(*v.UserId); err != nil { 3435 return err 3436 } 3437 } 3438 3439 return nil 3440} 3441 3442func awsRestjson1_serializeOpDocumentUpdateUserInput(v *UpdateUserInput, value smithyjson.Value) error { 3443 object := value.Object() 3444 defer object.Close() 3445 3446 if v.GivenName != nil { 3447 ok := object.Key("GivenName") 3448 ok.String(*v.GivenName) 3449 } 3450 3451 if len(v.GrantPoweruserPrivileges) > 0 { 3452 ok := object.Key("GrantPoweruserPrivileges") 3453 ok.String(string(v.GrantPoweruserPrivileges)) 3454 } 3455 3456 if len(v.Locale) > 0 { 3457 ok := object.Key("Locale") 3458 ok.String(string(v.Locale)) 3459 } 3460 3461 if v.StorageRule != nil { 3462 ok := object.Key("StorageRule") 3463 if err := awsRestjson1_serializeDocumentStorageRuleType(v.StorageRule, ok); err != nil { 3464 return err 3465 } 3466 } 3467 3468 if v.Surname != nil { 3469 ok := object.Key("Surname") 3470 ok.String(*v.Surname) 3471 } 3472 3473 if v.TimeZoneId != nil { 3474 ok := object.Key("TimeZoneId") 3475 ok.String(*v.TimeZoneId) 3476 } 3477 3478 if len(v.Type) > 0 { 3479 ok := object.Key("Type") 3480 ok.String(string(v.Type)) 3481 } 3482 3483 return nil 3484} 3485 3486func awsRestjson1_serializeDocumentCustomMetadataMap(v map[string]string, value smithyjson.Value) error { 3487 object := value.Object() 3488 defer object.Close() 3489 3490 for key := range v { 3491 om := object.Key(key) 3492 om.String(v[key]) 3493 } 3494 return nil 3495} 3496 3497func awsRestjson1_serializeDocumentNotificationOptions(v *types.NotificationOptions, value smithyjson.Value) error { 3498 object := value.Object() 3499 defer object.Close() 3500 3501 if v.EmailMessage != nil { 3502 ok := object.Key("EmailMessage") 3503 ok.String(*v.EmailMessage) 3504 } 3505 3506 if v.SendEmail { 3507 ok := object.Key("SendEmail") 3508 ok.Boolean(v.SendEmail) 3509 } 3510 3511 return nil 3512} 3513 3514func awsRestjson1_serializeDocumentSharedLabels(v []string, value smithyjson.Value) error { 3515 array := value.Array() 3516 defer array.Close() 3517 3518 for i := range v { 3519 av := array.Value() 3520 av.String(v[i]) 3521 } 3522 return nil 3523} 3524 3525func awsRestjson1_serializeDocumentSharePrincipal(v *types.SharePrincipal, value smithyjson.Value) error { 3526 object := value.Object() 3527 defer object.Close() 3528 3529 if v.Id != nil { 3530 ok := object.Key("Id") 3531 ok.String(*v.Id) 3532 } 3533 3534 if len(v.Role) > 0 { 3535 ok := object.Key("Role") 3536 ok.String(string(v.Role)) 3537 } 3538 3539 if len(v.Type) > 0 { 3540 ok := object.Key("Type") 3541 ok.String(string(v.Type)) 3542 } 3543 3544 return nil 3545} 3546 3547func awsRestjson1_serializeDocumentSharePrincipalList(v []types.SharePrincipal, value smithyjson.Value) error { 3548 array := value.Array() 3549 defer array.Close() 3550 3551 for i := range v { 3552 av := array.Value() 3553 if err := awsRestjson1_serializeDocumentSharePrincipal(&v[i], av); err != nil { 3554 return err 3555 } 3556 } 3557 return nil 3558} 3559 3560func awsRestjson1_serializeDocumentStorageRuleType(v *types.StorageRuleType, value smithyjson.Value) error { 3561 object := value.Object() 3562 defer object.Close() 3563 3564 if v.StorageAllocatedInBytes != nil { 3565 ok := object.Key("StorageAllocatedInBytes") 3566 ok.Long(*v.StorageAllocatedInBytes) 3567 } 3568 3569 if len(v.StorageType) > 0 { 3570 ok := object.Key("StorageType") 3571 ok.String(string(v.StorageType)) 3572 } 3573 3574 return nil 3575} 3576