1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package glacier 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/glacier/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 smithyhttp "github.com/aws/smithy-go/transport/http" 15) 16 17type awsRestjson1_serializeOpAbortMultipartUpload struct { 18} 19 20func (*awsRestjson1_serializeOpAbortMultipartUpload) ID() string { 21 return "OperationSerializer" 22} 23 24func (m *awsRestjson1_serializeOpAbortMultipartUpload) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 25 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 26) { 27 request, ok := in.Request.(*smithyhttp.Request) 28 if !ok { 29 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 30 } 31 32 input, ok := in.Parameters.(*AbortMultipartUploadInput) 33 _ = input 34 if !ok { 35 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 36 } 37 38 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}") 39 request.URL.Path = opPath 40 if len(request.URL.RawQuery) > 0 { 41 request.URL.RawQuery = "&" + opQuery 42 } else { 43 request.URL.RawQuery = opQuery 44 } 45 46 request.Method = "DELETE" 47 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 48 if err != nil { 49 return out, metadata, &smithy.SerializationError{Err: err} 50 } 51 52 if err := awsRestjson1_serializeOpHttpBindingsAbortMultipartUploadInput(input, restEncoder); err != nil { 53 return out, metadata, &smithy.SerializationError{Err: err} 54 } 55 56 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 57 return out, metadata, &smithy.SerializationError{Err: err} 58 } 59 in.Request = request 60 61 return next.HandleSerialize(ctx, in) 62} 63func awsRestjson1_serializeOpHttpBindingsAbortMultipartUploadInput(v *AbortMultipartUploadInput, encoder *httpbinding.Encoder) error { 64 if v == nil { 65 return fmt.Errorf("unsupported serialization of nil %T", v) 66 } 67 68 if v.AccountId == nil || len(*v.AccountId) == 0 { 69 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 70 } 71 if v.AccountId != nil { 72 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 73 return err 74 } 75 } 76 77 if v.UploadId == nil || len(*v.UploadId) == 0 { 78 return &smithy.SerializationError{Err: fmt.Errorf("input member uploadId must not be empty")} 79 } 80 if v.UploadId != nil { 81 if err := encoder.SetURI("uploadId").String(*v.UploadId); err != nil { 82 return err 83 } 84 } 85 86 if v.VaultName == nil || len(*v.VaultName) == 0 { 87 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 88 } 89 if v.VaultName != nil { 90 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 91 return err 92 } 93 } 94 95 return nil 96} 97 98type awsRestjson1_serializeOpAbortVaultLock struct { 99} 100 101func (*awsRestjson1_serializeOpAbortVaultLock) ID() string { 102 return "OperationSerializer" 103} 104 105func (m *awsRestjson1_serializeOpAbortVaultLock) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 106 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 107) { 108 request, ok := in.Request.(*smithyhttp.Request) 109 if !ok { 110 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 111 } 112 113 input, ok := in.Parameters.(*AbortVaultLockInput) 114 _ = input 115 if !ok { 116 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 117 } 118 119 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/lock-policy") 120 request.URL.Path = opPath 121 if len(request.URL.RawQuery) > 0 { 122 request.URL.RawQuery = "&" + opQuery 123 } else { 124 request.URL.RawQuery = opQuery 125 } 126 127 request.Method = "DELETE" 128 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 129 if err != nil { 130 return out, metadata, &smithy.SerializationError{Err: err} 131 } 132 133 if err := awsRestjson1_serializeOpHttpBindingsAbortVaultLockInput(input, restEncoder); err != nil { 134 return out, metadata, &smithy.SerializationError{Err: err} 135 } 136 137 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 138 return out, metadata, &smithy.SerializationError{Err: err} 139 } 140 in.Request = request 141 142 return next.HandleSerialize(ctx, in) 143} 144func awsRestjson1_serializeOpHttpBindingsAbortVaultLockInput(v *AbortVaultLockInput, encoder *httpbinding.Encoder) error { 145 if v == nil { 146 return fmt.Errorf("unsupported serialization of nil %T", v) 147 } 148 149 if v.AccountId == nil || len(*v.AccountId) == 0 { 150 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 151 } 152 if v.AccountId != nil { 153 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 154 return err 155 } 156 } 157 158 if v.VaultName == nil || len(*v.VaultName) == 0 { 159 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 160 } 161 if v.VaultName != nil { 162 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 163 return err 164 } 165 } 166 167 return nil 168} 169 170type awsRestjson1_serializeOpAddTagsToVault struct { 171} 172 173func (*awsRestjson1_serializeOpAddTagsToVault) ID() string { 174 return "OperationSerializer" 175} 176 177func (m *awsRestjson1_serializeOpAddTagsToVault) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 178 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 179) { 180 request, ok := in.Request.(*smithyhttp.Request) 181 if !ok { 182 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 183 } 184 185 input, ok := in.Parameters.(*AddTagsToVaultInput) 186 _ = input 187 if !ok { 188 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 189 } 190 191 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/tags?operation=add") 192 request.URL.Path = opPath 193 if len(request.URL.RawQuery) > 0 { 194 request.URL.RawQuery = "&" + opQuery 195 } else { 196 request.URL.RawQuery = opQuery 197 } 198 199 request.Method = "POST" 200 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 201 if err != nil { 202 return out, metadata, &smithy.SerializationError{Err: err} 203 } 204 205 if err := awsRestjson1_serializeOpHttpBindingsAddTagsToVaultInput(input, restEncoder); err != nil { 206 return out, metadata, &smithy.SerializationError{Err: err} 207 } 208 209 restEncoder.SetHeader("Content-Type").String("application/json") 210 211 jsonEncoder := smithyjson.NewEncoder() 212 if err := awsRestjson1_serializeOpDocumentAddTagsToVaultInput(input, jsonEncoder.Value); err != nil { 213 return out, metadata, &smithy.SerializationError{Err: err} 214 } 215 216 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 217 return out, metadata, &smithy.SerializationError{Err: err} 218 } 219 220 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 221 return out, metadata, &smithy.SerializationError{Err: err} 222 } 223 in.Request = request 224 225 return next.HandleSerialize(ctx, in) 226} 227func awsRestjson1_serializeOpHttpBindingsAddTagsToVaultInput(v *AddTagsToVaultInput, encoder *httpbinding.Encoder) error { 228 if v == nil { 229 return fmt.Errorf("unsupported serialization of nil %T", v) 230 } 231 232 if v.AccountId == nil || len(*v.AccountId) == 0 { 233 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 234 } 235 if v.AccountId != nil { 236 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 237 return err 238 } 239 } 240 241 if v.VaultName == nil || len(*v.VaultName) == 0 { 242 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 243 } 244 if v.VaultName != nil { 245 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 246 return err 247 } 248 } 249 250 return nil 251} 252 253func awsRestjson1_serializeOpDocumentAddTagsToVaultInput(v *AddTagsToVaultInput, value smithyjson.Value) error { 254 object := value.Object() 255 defer object.Close() 256 257 if v.Tags != nil { 258 ok := object.Key("Tags") 259 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 260 return err 261 } 262 } 263 264 return nil 265} 266 267type awsRestjson1_serializeOpCompleteMultipartUpload struct { 268} 269 270func (*awsRestjson1_serializeOpCompleteMultipartUpload) ID() string { 271 return "OperationSerializer" 272} 273 274func (m *awsRestjson1_serializeOpCompleteMultipartUpload) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 275 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 276) { 277 request, ok := in.Request.(*smithyhttp.Request) 278 if !ok { 279 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 280 } 281 282 input, ok := in.Parameters.(*CompleteMultipartUploadInput) 283 _ = input 284 if !ok { 285 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 286 } 287 288 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}") 289 request.URL.Path = opPath 290 if len(request.URL.RawQuery) > 0 { 291 request.URL.RawQuery = "&" + opQuery 292 } else { 293 request.URL.RawQuery = opQuery 294 } 295 296 request.Method = "POST" 297 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 298 if err != nil { 299 return out, metadata, &smithy.SerializationError{Err: err} 300 } 301 302 if err := awsRestjson1_serializeOpHttpBindingsCompleteMultipartUploadInput(input, restEncoder); err != nil { 303 return out, metadata, &smithy.SerializationError{Err: err} 304 } 305 306 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 307 return out, metadata, &smithy.SerializationError{Err: err} 308 } 309 in.Request = request 310 311 return next.HandleSerialize(ctx, in) 312} 313func awsRestjson1_serializeOpHttpBindingsCompleteMultipartUploadInput(v *CompleteMultipartUploadInput, encoder *httpbinding.Encoder) error { 314 if v == nil { 315 return fmt.Errorf("unsupported serialization of nil %T", v) 316 } 317 318 if v.AccountId == nil || len(*v.AccountId) == 0 { 319 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 320 } 321 if v.AccountId != nil { 322 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 323 return err 324 } 325 } 326 327 if v.ArchiveSize != nil && len(*v.ArchiveSize) > 0 { 328 locationName := "X-Amz-Archive-Size" 329 encoder.SetHeader(locationName).String(*v.ArchiveSize) 330 } 331 332 if v.Checksum != nil && len(*v.Checksum) > 0 { 333 locationName := "X-Amz-Sha256-Tree-Hash" 334 encoder.SetHeader(locationName).String(*v.Checksum) 335 } 336 337 if v.UploadId == nil || len(*v.UploadId) == 0 { 338 return &smithy.SerializationError{Err: fmt.Errorf("input member uploadId must not be empty")} 339 } 340 if v.UploadId != nil { 341 if err := encoder.SetURI("uploadId").String(*v.UploadId); err != nil { 342 return err 343 } 344 } 345 346 if v.VaultName == nil || len(*v.VaultName) == 0 { 347 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 348 } 349 if v.VaultName != nil { 350 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 351 return err 352 } 353 } 354 355 return nil 356} 357 358type awsRestjson1_serializeOpCompleteVaultLock struct { 359} 360 361func (*awsRestjson1_serializeOpCompleteVaultLock) ID() string { 362 return "OperationSerializer" 363} 364 365func (m *awsRestjson1_serializeOpCompleteVaultLock) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 366 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 367) { 368 request, ok := in.Request.(*smithyhttp.Request) 369 if !ok { 370 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 371 } 372 373 input, ok := in.Parameters.(*CompleteVaultLockInput) 374 _ = input 375 if !ok { 376 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 377 } 378 379 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/lock-policy/{lockId}") 380 request.URL.Path = opPath 381 if len(request.URL.RawQuery) > 0 { 382 request.URL.RawQuery = "&" + opQuery 383 } else { 384 request.URL.RawQuery = opQuery 385 } 386 387 request.Method = "POST" 388 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 389 if err != nil { 390 return out, metadata, &smithy.SerializationError{Err: err} 391 } 392 393 if err := awsRestjson1_serializeOpHttpBindingsCompleteVaultLockInput(input, restEncoder); err != nil { 394 return out, metadata, &smithy.SerializationError{Err: err} 395 } 396 397 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 398 return out, metadata, &smithy.SerializationError{Err: err} 399 } 400 in.Request = request 401 402 return next.HandleSerialize(ctx, in) 403} 404func awsRestjson1_serializeOpHttpBindingsCompleteVaultLockInput(v *CompleteVaultLockInput, encoder *httpbinding.Encoder) error { 405 if v == nil { 406 return fmt.Errorf("unsupported serialization of nil %T", v) 407 } 408 409 if v.AccountId == nil || len(*v.AccountId) == 0 { 410 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 411 } 412 if v.AccountId != nil { 413 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 414 return err 415 } 416 } 417 418 if v.LockId == nil || len(*v.LockId) == 0 { 419 return &smithy.SerializationError{Err: fmt.Errorf("input member lockId must not be empty")} 420 } 421 if v.LockId != nil { 422 if err := encoder.SetURI("lockId").String(*v.LockId); err != nil { 423 return err 424 } 425 } 426 427 if v.VaultName == nil || len(*v.VaultName) == 0 { 428 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 429 } 430 if v.VaultName != nil { 431 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 432 return err 433 } 434 } 435 436 return nil 437} 438 439type awsRestjson1_serializeOpCreateVault struct { 440} 441 442func (*awsRestjson1_serializeOpCreateVault) ID() string { 443 return "OperationSerializer" 444} 445 446func (m *awsRestjson1_serializeOpCreateVault) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 447 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 448) { 449 request, ok := in.Request.(*smithyhttp.Request) 450 if !ok { 451 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 452 } 453 454 input, ok := in.Parameters.(*CreateVaultInput) 455 _ = input 456 if !ok { 457 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 458 } 459 460 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}") 461 request.URL.Path = opPath 462 if len(request.URL.RawQuery) > 0 { 463 request.URL.RawQuery = "&" + opQuery 464 } else { 465 request.URL.RawQuery = opQuery 466 } 467 468 request.Method = "PUT" 469 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 470 if err != nil { 471 return out, metadata, &smithy.SerializationError{Err: err} 472 } 473 474 if err := awsRestjson1_serializeOpHttpBindingsCreateVaultInput(input, restEncoder); err != nil { 475 return out, metadata, &smithy.SerializationError{Err: err} 476 } 477 478 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 479 return out, metadata, &smithy.SerializationError{Err: err} 480 } 481 in.Request = request 482 483 return next.HandleSerialize(ctx, in) 484} 485func awsRestjson1_serializeOpHttpBindingsCreateVaultInput(v *CreateVaultInput, encoder *httpbinding.Encoder) error { 486 if v == nil { 487 return fmt.Errorf("unsupported serialization of nil %T", v) 488 } 489 490 if v.AccountId == nil || len(*v.AccountId) == 0 { 491 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 492 } 493 if v.AccountId != nil { 494 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 495 return err 496 } 497 } 498 499 if v.VaultName == nil || len(*v.VaultName) == 0 { 500 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 501 } 502 if v.VaultName != nil { 503 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 504 return err 505 } 506 } 507 508 return nil 509} 510 511type awsRestjson1_serializeOpDeleteArchive struct { 512} 513 514func (*awsRestjson1_serializeOpDeleteArchive) ID() string { 515 return "OperationSerializer" 516} 517 518func (m *awsRestjson1_serializeOpDeleteArchive) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 519 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 520) { 521 request, ok := in.Request.(*smithyhttp.Request) 522 if !ok { 523 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 524 } 525 526 input, ok := in.Parameters.(*DeleteArchiveInput) 527 _ = input 528 if !ok { 529 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 530 } 531 532 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/archives/{archiveId}") 533 request.URL.Path = opPath 534 if len(request.URL.RawQuery) > 0 { 535 request.URL.RawQuery = "&" + opQuery 536 } else { 537 request.URL.RawQuery = opQuery 538 } 539 540 request.Method = "DELETE" 541 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 542 if err != nil { 543 return out, metadata, &smithy.SerializationError{Err: err} 544 } 545 546 if err := awsRestjson1_serializeOpHttpBindingsDeleteArchiveInput(input, restEncoder); err != nil { 547 return out, metadata, &smithy.SerializationError{Err: err} 548 } 549 550 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 551 return out, metadata, &smithy.SerializationError{Err: err} 552 } 553 in.Request = request 554 555 return next.HandleSerialize(ctx, in) 556} 557func awsRestjson1_serializeOpHttpBindingsDeleteArchiveInput(v *DeleteArchiveInput, encoder *httpbinding.Encoder) error { 558 if v == nil { 559 return fmt.Errorf("unsupported serialization of nil %T", v) 560 } 561 562 if v.AccountId == nil || len(*v.AccountId) == 0 { 563 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 564 } 565 if v.AccountId != nil { 566 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 567 return err 568 } 569 } 570 571 if v.ArchiveId == nil || len(*v.ArchiveId) == 0 { 572 return &smithy.SerializationError{Err: fmt.Errorf("input member archiveId must not be empty")} 573 } 574 if v.ArchiveId != nil { 575 if err := encoder.SetURI("archiveId").String(*v.ArchiveId); err != nil { 576 return err 577 } 578 } 579 580 if v.VaultName == nil || len(*v.VaultName) == 0 { 581 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 582 } 583 if v.VaultName != nil { 584 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 585 return err 586 } 587 } 588 589 return nil 590} 591 592type awsRestjson1_serializeOpDeleteVault struct { 593} 594 595func (*awsRestjson1_serializeOpDeleteVault) ID() string { 596 return "OperationSerializer" 597} 598 599func (m *awsRestjson1_serializeOpDeleteVault) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 600 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 601) { 602 request, ok := in.Request.(*smithyhttp.Request) 603 if !ok { 604 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 605 } 606 607 input, ok := in.Parameters.(*DeleteVaultInput) 608 _ = input 609 if !ok { 610 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 611 } 612 613 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}") 614 request.URL.Path = opPath 615 if len(request.URL.RawQuery) > 0 { 616 request.URL.RawQuery = "&" + opQuery 617 } else { 618 request.URL.RawQuery = opQuery 619 } 620 621 request.Method = "DELETE" 622 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 623 if err != nil { 624 return out, metadata, &smithy.SerializationError{Err: err} 625 } 626 627 if err := awsRestjson1_serializeOpHttpBindingsDeleteVaultInput(input, restEncoder); err != nil { 628 return out, metadata, &smithy.SerializationError{Err: err} 629 } 630 631 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 632 return out, metadata, &smithy.SerializationError{Err: err} 633 } 634 in.Request = request 635 636 return next.HandleSerialize(ctx, in) 637} 638func awsRestjson1_serializeOpHttpBindingsDeleteVaultInput(v *DeleteVaultInput, encoder *httpbinding.Encoder) error { 639 if v == nil { 640 return fmt.Errorf("unsupported serialization of nil %T", v) 641 } 642 643 if v.AccountId == nil || len(*v.AccountId) == 0 { 644 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 645 } 646 if v.AccountId != nil { 647 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 648 return err 649 } 650 } 651 652 if v.VaultName == nil || len(*v.VaultName) == 0 { 653 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 654 } 655 if v.VaultName != nil { 656 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 657 return err 658 } 659 } 660 661 return nil 662} 663 664type awsRestjson1_serializeOpDeleteVaultAccessPolicy struct { 665} 666 667func (*awsRestjson1_serializeOpDeleteVaultAccessPolicy) ID() string { 668 return "OperationSerializer" 669} 670 671func (m *awsRestjson1_serializeOpDeleteVaultAccessPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 672 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 673) { 674 request, ok := in.Request.(*smithyhttp.Request) 675 if !ok { 676 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 677 } 678 679 input, ok := in.Parameters.(*DeleteVaultAccessPolicyInput) 680 _ = input 681 if !ok { 682 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 683 } 684 685 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/access-policy") 686 request.URL.Path = opPath 687 if len(request.URL.RawQuery) > 0 { 688 request.URL.RawQuery = "&" + opQuery 689 } else { 690 request.URL.RawQuery = opQuery 691 } 692 693 request.Method = "DELETE" 694 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 695 if err != nil { 696 return out, metadata, &smithy.SerializationError{Err: err} 697 } 698 699 if err := awsRestjson1_serializeOpHttpBindingsDeleteVaultAccessPolicyInput(input, restEncoder); err != nil { 700 return out, metadata, &smithy.SerializationError{Err: err} 701 } 702 703 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 704 return out, metadata, &smithy.SerializationError{Err: err} 705 } 706 in.Request = request 707 708 return next.HandleSerialize(ctx, in) 709} 710func awsRestjson1_serializeOpHttpBindingsDeleteVaultAccessPolicyInput(v *DeleteVaultAccessPolicyInput, encoder *httpbinding.Encoder) error { 711 if v == nil { 712 return fmt.Errorf("unsupported serialization of nil %T", v) 713 } 714 715 if v.AccountId == nil || len(*v.AccountId) == 0 { 716 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 717 } 718 if v.AccountId != nil { 719 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 720 return err 721 } 722 } 723 724 if v.VaultName == nil || len(*v.VaultName) == 0 { 725 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 726 } 727 if v.VaultName != nil { 728 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 729 return err 730 } 731 } 732 733 return nil 734} 735 736type awsRestjson1_serializeOpDeleteVaultNotifications struct { 737} 738 739func (*awsRestjson1_serializeOpDeleteVaultNotifications) ID() string { 740 return "OperationSerializer" 741} 742 743func (m *awsRestjson1_serializeOpDeleteVaultNotifications) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 744 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 745) { 746 request, ok := in.Request.(*smithyhttp.Request) 747 if !ok { 748 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 749 } 750 751 input, ok := in.Parameters.(*DeleteVaultNotificationsInput) 752 _ = input 753 if !ok { 754 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 755 } 756 757 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/notification-configuration") 758 request.URL.Path = opPath 759 if len(request.URL.RawQuery) > 0 { 760 request.URL.RawQuery = "&" + opQuery 761 } else { 762 request.URL.RawQuery = opQuery 763 } 764 765 request.Method = "DELETE" 766 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 767 if err != nil { 768 return out, metadata, &smithy.SerializationError{Err: err} 769 } 770 771 if err := awsRestjson1_serializeOpHttpBindingsDeleteVaultNotificationsInput(input, restEncoder); err != nil { 772 return out, metadata, &smithy.SerializationError{Err: err} 773 } 774 775 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 776 return out, metadata, &smithy.SerializationError{Err: err} 777 } 778 in.Request = request 779 780 return next.HandleSerialize(ctx, in) 781} 782func awsRestjson1_serializeOpHttpBindingsDeleteVaultNotificationsInput(v *DeleteVaultNotificationsInput, encoder *httpbinding.Encoder) error { 783 if v == nil { 784 return fmt.Errorf("unsupported serialization of nil %T", v) 785 } 786 787 if v.AccountId == nil || len(*v.AccountId) == 0 { 788 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 789 } 790 if v.AccountId != nil { 791 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 792 return err 793 } 794 } 795 796 if v.VaultName == nil || len(*v.VaultName) == 0 { 797 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 798 } 799 if v.VaultName != nil { 800 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 801 return err 802 } 803 } 804 805 return nil 806} 807 808type awsRestjson1_serializeOpDescribeJob struct { 809} 810 811func (*awsRestjson1_serializeOpDescribeJob) ID() string { 812 return "OperationSerializer" 813} 814 815func (m *awsRestjson1_serializeOpDescribeJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 816 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 817) { 818 request, ok := in.Request.(*smithyhttp.Request) 819 if !ok { 820 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 821 } 822 823 input, ok := in.Parameters.(*DescribeJobInput) 824 _ = input 825 if !ok { 826 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 827 } 828 829 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/jobs/{jobId}") 830 request.URL.Path = opPath 831 if len(request.URL.RawQuery) > 0 { 832 request.URL.RawQuery = "&" + opQuery 833 } else { 834 request.URL.RawQuery = opQuery 835 } 836 837 request.Method = "GET" 838 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 839 if err != nil { 840 return out, metadata, &smithy.SerializationError{Err: err} 841 } 842 843 if err := awsRestjson1_serializeOpHttpBindingsDescribeJobInput(input, restEncoder); err != nil { 844 return out, metadata, &smithy.SerializationError{Err: err} 845 } 846 847 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 848 return out, metadata, &smithy.SerializationError{Err: err} 849 } 850 in.Request = request 851 852 return next.HandleSerialize(ctx, in) 853} 854func awsRestjson1_serializeOpHttpBindingsDescribeJobInput(v *DescribeJobInput, encoder *httpbinding.Encoder) error { 855 if v == nil { 856 return fmt.Errorf("unsupported serialization of nil %T", v) 857 } 858 859 if v.AccountId == nil || len(*v.AccountId) == 0 { 860 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 861 } 862 if v.AccountId != nil { 863 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 864 return err 865 } 866 } 867 868 if v.JobId == nil || len(*v.JobId) == 0 { 869 return &smithy.SerializationError{Err: fmt.Errorf("input member jobId must not be empty")} 870 } 871 if v.JobId != nil { 872 if err := encoder.SetURI("jobId").String(*v.JobId); err != nil { 873 return err 874 } 875 } 876 877 if v.VaultName == nil || len(*v.VaultName) == 0 { 878 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 879 } 880 if v.VaultName != nil { 881 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 882 return err 883 } 884 } 885 886 return nil 887} 888 889type awsRestjson1_serializeOpDescribeVault struct { 890} 891 892func (*awsRestjson1_serializeOpDescribeVault) ID() string { 893 return "OperationSerializer" 894} 895 896func (m *awsRestjson1_serializeOpDescribeVault) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 897 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 898) { 899 request, ok := in.Request.(*smithyhttp.Request) 900 if !ok { 901 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 902 } 903 904 input, ok := in.Parameters.(*DescribeVaultInput) 905 _ = input 906 if !ok { 907 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 908 } 909 910 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}") 911 request.URL.Path = opPath 912 if len(request.URL.RawQuery) > 0 { 913 request.URL.RawQuery = "&" + opQuery 914 } else { 915 request.URL.RawQuery = opQuery 916 } 917 918 request.Method = "GET" 919 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 920 if err != nil { 921 return out, metadata, &smithy.SerializationError{Err: err} 922 } 923 924 if err := awsRestjson1_serializeOpHttpBindingsDescribeVaultInput(input, restEncoder); err != nil { 925 return out, metadata, &smithy.SerializationError{Err: err} 926 } 927 928 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 929 return out, metadata, &smithy.SerializationError{Err: err} 930 } 931 in.Request = request 932 933 return next.HandleSerialize(ctx, in) 934} 935func awsRestjson1_serializeOpHttpBindingsDescribeVaultInput(v *DescribeVaultInput, encoder *httpbinding.Encoder) error { 936 if v == nil { 937 return fmt.Errorf("unsupported serialization of nil %T", v) 938 } 939 940 if v.AccountId == nil || len(*v.AccountId) == 0 { 941 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 942 } 943 if v.AccountId != nil { 944 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 945 return err 946 } 947 } 948 949 if v.VaultName == nil || len(*v.VaultName) == 0 { 950 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 951 } 952 if v.VaultName != nil { 953 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 954 return err 955 } 956 } 957 958 return nil 959} 960 961type awsRestjson1_serializeOpGetDataRetrievalPolicy struct { 962} 963 964func (*awsRestjson1_serializeOpGetDataRetrievalPolicy) ID() string { 965 return "OperationSerializer" 966} 967 968func (m *awsRestjson1_serializeOpGetDataRetrievalPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 969 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 970) { 971 request, ok := in.Request.(*smithyhttp.Request) 972 if !ok { 973 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 974 } 975 976 input, ok := in.Parameters.(*GetDataRetrievalPolicyInput) 977 _ = input 978 if !ok { 979 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 980 } 981 982 opPath, opQuery := httpbinding.SplitURI("/{accountId}/policies/data-retrieval") 983 request.URL.Path = opPath 984 if len(request.URL.RawQuery) > 0 { 985 request.URL.RawQuery = "&" + opQuery 986 } else { 987 request.URL.RawQuery = opQuery 988 } 989 990 request.Method = "GET" 991 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 992 if err != nil { 993 return out, metadata, &smithy.SerializationError{Err: err} 994 } 995 996 if err := awsRestjson1_serializeOpHttpBindingsGetDataRetrievalPolicyInput(input, restEncoder); err != nil { 997 return out, metadata, &smithy.SerializationError{Err: err} 998 } 999 1000 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1001 return out, metadata, &smithy.SerializationError{Err: err} 1002 } 1003 in.Request = request 1004 1005 return next.HandleSerialize(ctx, in) 1006} 1007func awsRestjson1_serializeOpHttpBindingsGetDataRetrievalPolicyInput(v *GetDataRetrievalPolicyInput, encoder *httpbinding.Encoder) error { 1008 if v == nil { 1009 return fmt.Errorf("unsupported serialization of nil %T", v) 1010 } 1011 1012 if v.AccountId == nil || len(*v.AccountId) == 0 { 1013 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 1014 } 1015 if v.AccountId != nil { 1016 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 1017 return err 1018 } 1019 } 1020 1021 return nil 1022} 1023 1024type awsRestjson1_serializeOpGetJobOutput struct { 1025} 1026 1027func (*awsRestjson1_serializeOpGetJobOutput) ID() string { 1028 return "OperationSerializer" 1029} 1030 1031func (m *awsRestjson1_serializeOpGetJobOutput) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1032 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1033) { 1034 request, ok := in.Request.(*smithyhttp.Request) 1035 if !ok { 1036 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1037 } 1038 1039 input, ok := in.Parameters.(*GetJobOutputInput) 1040 _ = input 1041 if !ok { 1042 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1043 } 1044 1045 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/jobs/{jobId}/output") 1046 request.URL.Path = opPath 1047 if len(request.URL.RawQuery) > 0 { 1048 request.URL.RawQuery = "&" + opQuery 1049 } else { 1050 request.URL.RawQuery = opQuery 1051 } 1052 1053 request.Method = "GET" 1054 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1055 if err != nil { 1056 return out, metadata, &smithy.SerializationError{Err: err} 1057 } 1058 1059 if err := awsRestjson1_serializeOpHttpBindingsGetJobOutputInput(input, restEncoder); err != nil { 1060 return out, metadata, &smithy.SerializationError{Err: err} 1061 } 1062 1063 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1064 return out, metadata, &smithy.SerializationError{Err: err} 1065 } 1066 in.Request = request 1067 1068 return next.HandleSerialize(ctx, in) 1069} 1070func awsRestjson1_serializeOpHttpBindingsGetJobOutputInput(v *GetJobOutputInput, encoder *httpbinding.Encoder) error { 1071 if v == nil { 1072 return fmt.Errorf("unsupported serialization of nil %T", v) 1073 } 1074 1075 if v.AccountId == nil || len(*v.AccountId) == 0 { 1076 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 1077 } 1078 if v.AccountId != nil { 1079 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 1080 return err 1081 } 1082 } 1083 1084 if v.JobId == nil || len(*v.JobId) == 0 { 1085 return &smithy.SerializationError{Err: fmt.Errorf("input member jobId must not be empty")} 1086 } 1087 if v.JobId != nil { 1088 if err := encoder.SetURI("jobId").String(*v.JobId); err != nil { 1089 return err 1090 } 1091 } 1092 1093 if v.Range != nil && len(*v.Range) > 0 { 1094 locationName := "Range" 1095 encoder.SetHeader(locationName).String(*v.Range) 1096 } 1097 1098 if v.VaultName == nil || len(*v.VaultName) == 0 { 1099 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 1100 } 1101 if v.VaultName != nil { 1102 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 1103 return err 1104 } 1105 } 1106 1107 return nil 1108} 1109 1110type awsRestjson1_serializeOpGetVaultAccessPolicy struct { 1111} 1112 1113func (*awsRestjson1_serializeOpGetVaultAccessPolicy) ID() string { 1114 return "OperationSerializer" 1115} 1116 1117func (m *awsRestjson1_serializeOpGetVaultAccessPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1118 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1119) { 1120 request, ok := in.Request.(*smithyhttp.Request) 1121 if !ok { 1122 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1123 } 1124 1125 input, ok := in.Parameters.(*GetVaultAccessPolicyInput) 1126 _ = input 1127 if !ok { 1128 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1129 } 1130 1131 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/access-policy") 1132 request.URL.Path = opPath 1133 if len(request.URL.RawQuery) > 0 { 1134 request.URL.RawQuery = "&" + opQuery 1135 } else { 1136 request.URL.RawQuery = opQuery 1137 } 1138 1139 request.Method = "GET" 1140 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1141 if err != nil { 1142 return out, metadata, &smithy.SerializationError{Err: err} 1143 } 1144 1145 if err := awsRestjson1_serializeOpHttpBindingsGetVaultAccessPolicyInput(input, restEncoder); err != nil { 1146 return out, metadata, &smithy.SerializationError{Err: err} 1147 } 1148 1149 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1150 return out, metadata, &smithy.SerializationError{Err: err} 1151 } 1152 in.Request = request 1153 1154 return next.HandleSerialize(ctx, in) 1155} 1156func awsRestjson1_serializeOpHttpBindingsGetVaultAccessPolicyInput(v *GetVaultAccessPolicyInput, encoder *httpbinding.Encoder) error { 1157 if v == nil { 1158 return fmt.Errorf("unsupported serialization of nil %T", v) 1159 } 1160 1161 if v.AccountId == nil || len(*v.AccountId) == 0 { 1162 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 1163 } 1164 if v.AccountId != nil { 1165 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 1166 return err 1167 } 1168 } 1169 1170 if v.VaultName == nil || len(*v.VaultName) == 0 { 1171 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 1172 } 1173 if v.VaultName != nil { 1174 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 1175 return err 1176 } 1177 } 1178 1179 return nil 1180} 1181 1182type awsRestjson1_serializeOpGetVaultLock struct { 1183} 1184 1185func (*awsRestjson1_serializeOpGetVaultLock) ID() string { 1186 return "OperationSerializer" 1187} 1188 1189func (m *awsRestjson1_serializeOpGetVaultLock) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1190 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1191) { 1192 request, ok := in.Request.(*smithyhttp.Request) 1193 if !ok { 1194 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1195 } 1196 1197 input, ok := in.Parameters.(*GetVaultLockInput) 1198 _ = input 1199 if !ok { 1200 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1201 } 1202 1203 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/lock-policy") 1204 request.URL.Path = opPath 1205 if len(request.URL.RawQuery) > 0 { 1206 request.URL.RawQuery = "&" + opQuery 1207 } else { 1208 request.URL.RawQuery = opQuery 1209 } 1210 1211 request.Method = "GET" 1212 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1213 if err != nil { 1214 return out, metadata, &smithy.SerializationError{Err: err} 1215 } 1216 1217 if err := awsRestjson1_serializeOpHttpBindingsGetVaultLockInput(input, restEncoder); err != nil { 1218 return out, metadata, &smithy.SerializationError{Err: err} 1219 } 1220 1221 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1222 return out, metadata, &smithy.SerializationError{Err: err} 1223 } 1224 in.Request = request 1225 1226 return next.HandleSerialize(ctx, in) 1227} 1228func awsRestjson1_serializeOpHttpBindingsGetVaultLockInput(v *GetVaultLockInput, encoder *httpbinding.Encoder) error { 1229 if v == nil { 1230 return fmt.Errorf("unsupported serialization of nil %T", v) 1231 } 1232 1233 if v.AccountId == nil || len(*v.AccountId) == 0 { 1234 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 1235 } 1236 if v.AccountId != nil { 1237 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 1238 return err 1239 } 1240 } 1241 1242 if v.VaultName == nil || len(*v.VaultName) == 0 { 1243 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 1244 } 1245 if v.VaultName != nil { 1246 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 1247 return err 1248 } 1249 } 1250 1251 return nil 1252} 1253 1254type awsRestjson1_serializeOpGetVaultNotifications struct { 1255} 1256 1257func (*awsRestjson1_serializeOpGetVaultNotifications) ID() string { 1258 return "OperationSerializer" 1259} 1260 1261func (m *awsRestjson1_serializeOpGetVaultNotifications) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1262 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1263) { 1264 request, ok := in.Request.(*smithyhttp.Request) 1265 if !ok { 1266 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1267 } 1268 1269 input, ok := in.Parameters.(*GetVaultNotificationsInput) 1270 _ = input 1271 if !ok { 1272 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1273 } 1274 1275 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/notification-configuration") 1276 request.URL.Path = opPath 1277 if len(request.URL.RawQuery) > 0 { 1278 request.URL.RawQuery = "&" + opQuery 1279 } else { 1280 request.URL.RawQuery = opQuery 1281 } 1282 1283 request.Method = "GET" 1284 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1285 if err != nil { 1286 return out, metadata, &smithy.SerializationError{Err: err} 1287 } 1288 1289 if err := awsRestjson1_serializeOpHttpBindingsGetVaultNotificationsInput(input, restEncoder); err != nil { 1290 return out, metadata, &smithy.SerializationError{Err: err} 1291 } 1292 1293 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1294 return out, metadata, &smithy.SerializationError{Err: err} 1295 } 1296 in.Request = request 1297 1298 return next.HandleSerialize(ctx, in) 1299} 1300func awsRestjson1_serializeOpHttpBindingsGetVaultNotificationsInput(v *GetVaultNotificationsInput, encoder *httpbinding.Encoder) error { 1301 if v == nil { 1302 return fmt.Errorf("unsupported serialization of nil %T", v) 1303 } 1304 1305 if v.AccountId == nil || len(*v.AccountId) == 0 { 1306 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 1307 } 1308 if v.AccountId != nil { 1309 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 1310 return err 1311 } 1312 } 1313 1314 if v.VaultName == nil || len(*v.VaultName) == 0 { 1315 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 1316 } 1317 if v.VaultName != nil { 1318 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 1319 return err 1320 } 1321 } 1322 1323 return nil 1324} 1325 1326type awsRestjson1_serializeOpInitiateJob struct { 1327} 1328 1329func (*awsRestjson1_serializeOpInitiateJob) ID() string { 1330 return "OperationSerializer" 1331} 1332 1333func (m *awsRestjson1_serializeOpInitiateJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1334 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1335) { 1336 request, ok := in.Request.(*smithyhttp.Request) 1337 if !ok { 1338 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1339 } 1340 1341 input, ok := in.Parameters.(*InitiateJobInput) 1342 _ = input 1343 if !ok { 1344 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1345 } 1346 1347 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/jobs") 1348 request.URL.Path = opPath 1349 if len(request.URL.RawQuery) > 0 { 1350 request.URL.RawQuery = "&" + opQuery 1351 } else { 1352 request.URL.RawQuery = opQuery 1353 } 1354 1355 request.Method = "POST" 1356 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1357 if err != nil { 1358 return out, metadata, &smithy.SerializationError{Err: err} 1359 } 1360 1361 if err := awsRestjson1_serializeOpHttpBindingsInitiateJobInput(input, restEncoder); err != nil { 1362 return out, metadata, &smithy.SerializationError{Err: err} 1363 } 1364 1365 if input.JobParameters != nil { 1366 if !restEncoder.HasHeader("Content-Type") { 1367 restEncoder.SetHeader("Content-Type").String("application/json") 1368 } 1369 1370 jsonEncoder := smithyjson.NewEncoder() 1371 if err := awsRestjson1_serializeDocumentJobParameters(input.JobParameters, jsonEncoder.Value); err != nil { 1372 return out, metadata, &smithy.SerializationError{Err: err} 1373 } 1374 payload := bytes.NewReader(jsonEncoder.Bytes()) 1375 if request, err = request.SetStream(payload); err != nil { 1376 return out, metadata, &smithy.SerializationError{Err: err} 1377 } 1378 } 1379 1380 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1381 return out, metadata, &smithy.SerializationError{Err: err} 1382 } 1383 in.Request = request 1384 1385 return next.HandleSerialize(ctx, in) 1386} 1387func awsRestjson1_serializeOpHttpBindingsInitiateJobInput(v *InitiateJobInput, encoder *httpbinding.Encoder) error { 1388 if v == nil { 1389 return fmt.Errorf("unsupported serialization of nil %T", v) 1390 } 1391 1392 if v.AccountId == nil || len(*v.AccountId) == 0 { 1393 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 1394 } 1395 if v.AccountId != nil { 1396 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 1397 return err 1398 } 1399 } 1400 1401 if v.VaultName == nil || len(*v.VaultName) == 0 { 1402 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 1403 } 1404 if v.VaultName != nil { 1405 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 1406 return err 1407 } 1408 } 1409 1410 return nil 1411} 1412 1413type awsRestjson1_serializeOpInitiateMultipartUpload struct { 1414} 1415 1416func (*awsRestjson1_serializeOpInitiateMultipartUpload) ID() string { 1417 return "OperationSerializer" 1418} 1419 1420func (m *awsRestjson1_serializeOpInitiateMultipartUpload) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1421 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1422) { 1423 request, ok := in.Request.(*smithyhttp.Request) 1424 if !ok { 1425 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1426 } 1427 1428 input, ok := in.Parameters.(*InitiateMultipartUploadInput) 1429 _ = input 1430 if !ok { 1431 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1432 } 1433 1434 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/multipart-uploads") 1435 request.URL.Path = opPath 1436 if len(request.URL.RawQuery) > 0 { 1437 request.URL.RawQuery = "&" + opQuery 1438 } else { 1439 request.URL.RawQuery = opQuery 1440 } 1441 1442 request.Method = "POST" 1443 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1444 if err != nil { 1445 return out, metadata, &smithy.SerializationError{Err: err} 1446 } 1447 1448 if err := awsRestjson1_serializeOpHttpBindingsInitiateMultipartUploadInput(input, restEncoder); err != nil { 1449 return out, metadata, &smithy.SerializationError{Err: err} 1450 } 1451 1452 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1453 return out, metadata, &smithy.SerializationError{Err: err} 1454 } 1455 in.Request = request 1456 1457 return next.HandleSerialize(ctx, in) 1458} 1459func awsRestjson1_serializeOpHttpBindingsInitiateMultipartUploadInput(v *InitiateMultipartUploadInput, encoder *httpbinding.Encoder) error { 1460 if v == nil { 1461 return fmt.Errorf("unsupported serialization of nil %T", v) 1462 } 1463 1464 if v.AccountId == nil || len(*v.AccountId) == 0 { 1465 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 1466 } 1467 if v.AccountId != nil { 1468 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 1469 return err 1470 } 1471 } 1472 1473 if v.ArchiveDescription != nil && len(*v.ArchiveDescription) > 0 { 1474 locationName := "X-Amz-Archive-Description" 1475 encoder.SetHeader(locationName).String(*v.ArchiveDescription) 1476 } 1477 1478 if v.PartSize != nil && len(*v.PartSize) > 0 { 1479 locationName := "X-Amz-Part-Size" 1480 encoder.SetHeader(locationName).String(*v.PartSize) 1481 } 1482 1483 if v.VaultName == nil || len(*v.VaultName) == 0 { 1484 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 1485 } 1486 if v.VaultName != nil { 1487 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 1488 return err 1489 } 1490 } 1491 1492 return nil 1493} 1494 1495type awsRestjson1_serializeOpInitiateVaultLock struct { 1496} 1497 1498func (*awsRestjson1_serializeOpInitiateVaultLock) ID() string { 1499 return "OperationSerializer" 1500} 1501 1502func (m *awsRestjson1_serializeOpInitiateVaultLock) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1503 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1504) { 1505 request, ok := in.Request.(*smithyhttp.Request) 1506 if !ok { 1507 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1508 } 1509 1510 input, ok := in.Parameters.(*InitiateVaultLockInput) 1511 _ = input 1512 if !ok { 1513 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1514 } 1515 1516 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/lock-policy") 1517 request.URL.Path = opPath 1518 if len(request.URL.RawQuery) > 0 { 1519 request.URL.RawQuery = "&" + opQuery 1520 } else { 1521 request.URL.RawQuery = opQuery 1522 } 1523 1524 request.Method = "POST" 1525 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1526 if err != nil { 1527 return out, metadata, &smithy.SerializationError{Err: err} 1528 } 1529 1530 if err := awsRestjson1_serializeOpHttpBindingsInitiateVaultLockInput(input, restEncoder); err != nil { 1531 return out, metadata, &smithy.SerializationError{Err: err} 1532 } 1533 1534 if input.Policy != nil { 1535 if !restEncoder.HasHeader("Content-Type") { 1536 restEncoder.SetHeader("Content-Type").String("application/json") 1537 } 1538 1539 jsonEncoder := smithyjson.NewEncoder() 1540 if err := awsRestjson1_serializeDocumentVaultLockPolicy(input.Policy, jsonEncoder.Value); err != nil { 1541 return out, metadata, &smithy.SerializationError{Err: err} 1542 } 1543 payload := bytes.NewReader(jsonEncoder.Bytes()) 1544 if request, err = request.SetStream(payload); err != nil { 1545 return out, metadata, &smithy.SerializationError{Err: err} 1546 } 1547 } 1548 1549 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1550 return out, metadata, &smithy.SerializationError{Err: err} 1551 } 1552 in.Request = request 1553 1554 return next.HandleSerialize(ctx, in) 1555} 1556func awsRestjson1_serializeOpHttpBindingsInitiateVaultLockInput(v *InitiateVaultLockInput, encoder *httpbinding.Encoder) error { 1557 if v == nil { 1558 return fmt.Errorf("unsupported serialization of nil %T", v) 1559 } 1560 1561 if v.AccountId == nil || len(*v.AccountId) == 0 { 1562 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 1563 } 1564 if v.AccountId != nil { 1565 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 1566 return err 1567 } 1568 } 1569 1570 if v.VaultName == nil || len(*v.VaultName) == 0 { 1571 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 1572 } 1573 if v.VaultName != nil { 1574 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 1575 return err 1576 } 1577 } 1578 1579 return nil 1580} 1581 1582type awsRestjson1_serializeOpListJobs struct { 1583} 1584 1585func (*awsRestjson1_serializeOpListJobs) ID() string { 1586 return "OperationSerializer" 1587} 1588 1589func (m *awsRestjson1_serializeOpListJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1590 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1591) { 1592 request, ok := in.Request.(*smithyhttp.Request) 1593 if !ok { 1594 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1595 } 1596 1597 input, ok := in.Parameters.(*ListJobsInput) 1598 _ = input 1599 if !ok { 1600 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1601 } 1602 1603 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/jobs") 1604 request.URL.Path = opPath 1605 if len(request.URL.RawQuery) > 0 { 1606 request.URL.RawQuery = "&" + opQuery 1607 } else { 1608 request.URL.RawQuery = opQuery 1609 } 1610 1611 request.Method = "GET" 1612 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1613 if err != nil { 1614 return out, metadata, &smithy.SerializationError{Err: err} 1615 } 1616 1617 if err := awsRestjson1_serializeOpHttpBindingsListJobsInput(input, restEncoder); err != nil { 1618 return out, metadata, &smithy.SerializationError{Err: err} 1619 } 1620 1621 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1622 return out, metadata, &smithy.SerializationError{Err: err} 1623 } 1624 in.Request = request 1625 1626 return next.HandleSerialize(ctx, in) 1627} 1628func awsRestjson1_serializeOpHttpBindingsListJobsInput(v *ListJobsInput, encoder *httpbinding.Encoder) error { 1629 if v == nil { 1630 return fmt.Errorf("unsupported serialization of nil %T", v) 1631 } 1632 1633 if v.AccountId == nil || len(*v.AccountId) == 0 { 1634 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 1635 } 1636 if v.AccountId != nil { 1637 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 1638 return err 1639 } 1640 } 1641 1642 if v.Completed != nil { 1643 encoder.SetQuery("completed").String(*v.Completed) 1644 } 1645 1646 if v.Limit != nil { 1647 encoder.SetQuery("limit").Integer(*v.Limit) 1648 } 1649 1650 if v.Marker != nil { 1651 encoder.SetQuery("marker").String(*v.Marker) 1652 } 1653 1654 if v.Statuscode != nil { 1655 encoder.SetQuery("statuscode").String(*v.Statuscode) 1656 } 1657 1658 if v.VaultName == nil || len(*v.VaultName) == 0 { 1659 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 1660 } 1661 if v.VaultName != nil { 1662 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 1663 return err 1664 } 1665 } 1666 1667 return nil 1668} 1669 1670type awsRestjson1_serializeOpListMultipartUploads struct { 1671} 1672 1673func (*awsRestjson1_serializeOpListMultipartUploads) ID() string { 1674 return "OperationSerializer" 1675} 1676 1677func (m *awsRestjson1_serializeOpListMultipartUploads) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1678 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1679) { 1680 request, ok := in.Request.(*smithyhttp.Request) 1681 if !ok { 1682 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1683 } 1684 1685 input, ok := in.Parameters.(*ListMultipartUploadsInput) 1686 _ = input 1687 if !ok { 1688 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1689 } 1690 1691 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/multipart-uploads") 1692 request.URL.Path = opPath 1693 if len(request.URL.RawQuery) > 0 { 1694 request.URL.RawQuery = "&" + opQuery 1695 } else { 1696 request.URL.RawQuery = opQuery 1697 } 1698 1699 request.Method = "GET" 1700 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1701 if err != nil { 1702 return out, metadata, &smithy.SerializationError{Err: err} 1703 } 1704 1705 if err := awsRestjson1_serializeOpHttpBindingsListMultipartUploadsInput(input, restEncoder); err != nil { 1706 return out, metadata, &smithy.SerializationError{Err: err} 1707 } 1708 1709 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1710 return out, metadata, &smithy.SerializationError{Err: err} 1711 } 1712 in.Request = request 1713 1714 return next.HandleSerialize(ctx, in) 1715} 1716func awsRestjson1_serializeOpHttpBindingsListMultipartUploadsInput(v *ListMultipartUploadsInput, encoder *httpbinding.Encoder) error { 1717 if v == nil { 1718 return fmt.Errorf("unsupported serialization of nil %T", v) 1719 } 1720 1721 if v.AccountId == nil || len(*v.AccountId) == 0 { 1722 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 1723 } 1724 if v.AccountId != nil { 1725 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 1726 return err 1727 } 1728 } 1729 1730 if v.Limit != nil { 1731 encoder.SetQuery("limit").Integer(*v.Limit) 1732 } 1733 1734 if v.Marker != nil { 1735 encoder.SetQuery("marker").String(*v.Marker) 1736 } 1737 1738 if v.VaultName == nil || len(*v.VaultName) == 0 { 1739 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 1740 } 1741 if v.VaultName != nil { 1742 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 1743 return err 1744 } 1745 } 1746 1747 return nil 1748} 1749 1750type awsRestjson1_serializeOpListParts struct { 1751} 1752 1753func (*awsRestjson1_serializeOpListParts) ID() string { 1754 return "OperationSerializer" 1755} 1756 1757func (m *awsRestjson1_serializeOpListParts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1758 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1759) { 1760 request, ok := in.Request.(*smithyhttp.Request) 1761 if !ok { 1762 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1763 } 1764 1765 input, ok := in.Parameters.(*ListPartsInput) 1766 _ = input 1767 if !ok { 1768 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1769 } 1770 1771 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}") 1772 request.URL.Path = opPath 1773 if len(request.URL.RawQuery) > 0 { 1774 request.URL.RawQuery = "&" + opQuery 1775 } else { 1776 request.URL.RawQuery = opQuery 1777 } 1778 1779 request.Method = "GET" 1780 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1781 if err != nil { 1782 return out, metadata, &smithy.SerializationError{Err: err} 1783 } 1784 1785 if err := awsRestjson1_serializeOpHttpBindingsListPartsInput(input, restEncoder); err != nil { 1786 return out, metadata, &smithy.SerializationError{Err: err} 1787 } 1788 1789 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1790 return out, metadata, &smithy.SerializationError{Err: err} 1791 } 1792 in.Request = request 1793 1794 return next.HandleSerialize(ctx, in) 1795} 1796func awsRestjson1_serializeOpHttpBindingsListPartsInput(v *ListPartsInput, encoder *httpbinding.Encoder) error { 1797 if v == nil { 1798 return fmt.Errorf("unsupported serialization of nil %T", v) 1799 } 1800 1801 if v.AccountId == nil || len(*v.AccountId) == 0 { 1802 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 1803 } 1804 if v.AccountId != nil { 1805 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 1806 return err 1807 } 1808 } 1809 1810 if v.Limit != nil { 1811 encoder.SetQuery("limit").Integer(*v.Limit) 1812 } 1813 1814 if v.Marker != nil { 1815 encoder.SetQuery("marker").String(*v.Marker) 1816 } 1817 1818 if v.UploadId == nil || len(*v.UploadId) == 0 { 1819 return &smithy.SerializationError{Err: fmt.Errorf("input member uploadId must not be empty")} 1820 } 1821 if v.UploadId != nil { 1822 if err := encoder.SetURI("uploadId").String(*v.UploadId); err != nil { 1823 return err 1824 } 1825 } 1826 1827 if v.VaultName == nil || len(*v.VaultName) == 0 { 1828 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 1829 } 1830 if v.VaultName != nil { 1831 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 1832 return err 1833 } 1834 } 1835 1836 return nil 1837} 1838 1839type awsRestjson1_serializeOpListProvisionedCapacity struct { 1840} 1841 1842func (*awsRestjson1_serializeOpListProvisionedCapacity) ID() string { 1843 return "OperationSerializer" 1844} 1845 1846func (m *awsRestjson1_serializeOpListProvisionedCapacity) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1847 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1848) { 1849 request, ok := in.Request.(*smithyhttp.Request) 1850 if !ok { 1851 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1852 } 1853 1854 input, ok := in.Parameters.(*ListProvisionedCapacityInput) 1855 _ = input 1856 if !ok { 1857 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1858 } 1859 1860 opPath, opQuery := httpbinding.SplitURI("/{accountId}/provisioned-capacity") 1861 request.URL.Path = opPath 1862 if len(request.URL.RawQuery) > 0 { 1863 request.URL.RawQuery = "&" + opQuery 1864 } else { 1865 request.URL.RawQuery = opQuery 1866 } 1867 1868 request.Method = "GET" 1869 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1870 if err != nil { 1871 return out, metadata, &smithy.SerializationError{Err: err} 1872 } 1873 1874 if err := awsRestjson1_serializeOpHttpBindingsListProvisionedCapacityInput(input, restEncoder); err != nil { 1875 return out, metadata, &smithy.SerializationError{Err: err} 1876 } 1877 1878 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1879 return out, metadata, &smithy.SerializationError{Err: err} 1880 } 1881 in.Request = request 1882 1883 return next.HandleSerialize(ctx, in) 1884} 1885func awsRestjson1_serializeOpHttpBindingsListProvisionedCapacityInput(v *ListProvisionedCapacityInput, encoder *httpbinding.Encoder) error { 1886 if v == nil { 1887 return fmt.Errorf("unsupported serialization of nil %T", v) 1888 } 1889 1890 if v.AccountId == nil || len(*v.AccountId) == 0 { 1891 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 1892 } 1893 if v.AccountId != nil { 1894 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 1895 return err 1896 } 1897 } 1898 1899 return nil 1900} 1901 1902type awsRestjson1_serializeOpListTagsForVault struct { 1903} 1904 1905func (*awsRestjson1_serializeOpListTagsForVault) ID() string { 1906 return "OperationSerializer" 1907} 1908 1909func (m *awsRestjson1_serializeOpListTagsForVault) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1910 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1911) { 1912 request, ok := in.Request.(*smithyhttp.Request) 1913 if !ok { 1914 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1915 } 1916 1917 input, ok := in.Parameters.(*ListTagsForVaultInput) 1918 _ = input 1919 if !ok { 1920 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1921 } 1922 1923 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/tags") 1924 request.URL.Path = opPath 1925 if len(request.URL.RawQuery) > 0 { 1926 request.URL.RawQuery = "&" + opQuery 1927 } else { 1928 request.URL.RawQuery = opQuery 1929 } 1930 1931 request.Method = "GET" 1932 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1933 if err != nil { 1934 return out, metadata, &smithy.SerializationError{Err: err} 1935 } 1936 1937 if err := awsRestjson1_serializeOpHttpBindingsListTagsForVaultInput(input, restEncoder); err != nil { 1938 return out, metadata, &smithy.SerializationError{Err: err} 1939 } 1940 1941 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1942 return out, metadata, &smithy.SerializationError{Err: err} 1943 } 1944 in.Request = request 1945 1946 return next.HandleSerialize(ctx, in) 1947} 1948func awsRestjson1_serializeOpHttpBindingsListTagsForVaultInput(v *ListTagsForVaultInput, encoder *httpbinding.Encoder) error { 1949 if v == nil { 1950 return fmt.Errorf("unsupported serialization of nil %T", v) 1951 } 1952 1953 if v.AccountId == nil || len(*v.AccountId) == 0 { 1954 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 1955 } 1956 if v.AccountId != nil { 1957 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 1958 return err 1959 } 1960 } 1961 1962 if v.VaultName == nil || len(*v.VaultName) == 0 { 1963 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 1964 } 1965 if v.VaultName != nil { 1966 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 1967 return err 1968 } 1969 } 1970 1971 return nil 1972} 1973 1974type awsRestjson1_serializeOpListVaults struct { 1975} 1976 1977func (*awsRestjson1_serializeOpListVaults) ID() string { 1978 return "OperationSerializer" 1979} 1980 1981func (m *awsRestjson1_serializeOpListVaults) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1982 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1983) { 1984 request, ok := in.Request.(*smithyhttp.Request) 1985 if !ok { 1986 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1987 } 1988 1989 input, ok := in.Parameters.(*ListVaultsInput) 1990 _ = input 1991 if !ok { 1992 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1993 } 1994 1995 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults") 1996 request.URL.Path = opPath 1997 if len(request.URL.RawQuery) > 0 { 1998 request.URL.RawQuery = "&" + opQuery 1999 } else { 2000 request.URL.RawQuery = opQuery 2001 } 2002 2003 request.Method = "GET" 2004 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2005 if err != nil { 2006 return out, metadata, &smithy.SerializationError{Err: err} 2007 } 2008 2009 if err := awsRestjson1_serializeOpHttpBindingsListVaultsInput(input, restEncoder); err != nil { 2010 return out, metadata, &smithy.SerializationError{Err: err} 2011 } 2012 2013 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2014 return out, metadata, &smithy.SerializationError{Err: err} 2015 } 2016 in.Request = request 2017 2018 return next.HandleSerialize(ctx, in) 2019} 2020func awsRestjson1_serializeOpHttpBindingsListVaultsInput(v *ListVaultsInput, encoder *httpbinding.Encoder) error { 2021 if v == nil { 2022 return fmt.Errorf("unsupported serialization of nil %T", v) 2023 } 2024 2025 if v.AccountId == nil || len(*v.AccountId) == 0 { 2026 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 2027 } 2028 if v.AccountId != nil { 2029 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 2030 return err 2031 } 2032 } 2033 2034 if v.Limit != nil { 2035 encoder.SetQuery("limit").Integer(*v.Limit) 2036 } 2037 2038 if v.Marker != nil { 2039 encoder.SetQuery("marker").String(*v.Marker) 2040 } 2041 2042 return nil 2043} 2044 2045type awsRestjson1_serializeOpPurchaseProvisionedCapacity struct { 2046} 2047 2048func (*awsRestjson1_serializeOpPurchaseProvisionedCapacity) ID() string { 2049 return "OperationSerializer" 2050} 2051 2052func (m *awsRestjson1_serializeOpPurchaseProvisionedCapacity) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2053 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2054) { 2055 request, ok := in.Request.(*smithyhttp.Request) 2056 if !ok { 2057 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2058 } 2059 2060 input, ok := in.Parameters.(*PurchaseProvisionedCapacityInput) 2061 _ = input 2062 if !ok { 2063 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2064 } 2065 2066 opPath, opQuery := httpbinding.SplitURI("/{accountId}/provisioned-capacity") 2067 request.URL.Path = opPath 2068 if len(request.URL.RawQuery) > 0 { 2069 request.URL.RawQuery = "&" + opQuery 2070 } else { 2071 request.URL.RawQuery = opQuery 2072 } 2073 2074 request.Method = "POST" 2075 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2076 if err != nil { 2077 return out, metadata, &smithy.SerializationError{Err: err} 2078 } 2079 2080 if err := awsRestjson1_serializeOpHttpBindingsPurchaseProvisionedCapacityInput(input, restEncoder); err != nil { 2081 return out, metadata, &smithy.SerializationError{Err: err} 2082 } 2083 2084 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2085 return out, metadata, &smithy.SerializationError{Err: err} 2086 } 2087 in.Request = request 2088 2089 return next.HandleSerialize(ctx, in) 2090} 2091func awsRestjson1_serializeOpHttpBindingsPurchaseProvisionedCapacityInput(v *PurchaseProvisionedCapacityInput, encoder *httpbinding.Encoder) error { 2092 if v == nil { 2093 return fmt.Errorf("unsupported serialization of nil %T", v) 2094 } 2095 2096 if v.AccountId == nil || len(*v.AccountId) == 0 { 2097 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 2098 } 2099 if v.AccountId != nil { 2100 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 2101 return err 2102 } 2103 } 2104 2105 return nil 2106} 2107 2108type awsRestjson1_serializeOpRemoveTagsFromVault struct { 2109} 2110 2111func (*awsRestjson1_serializeOpRemoveTagsFromVault) ID() string { 2112 return "OperationSerializer" 2113} 2114 2115func (m *awsRestjson1_serializeOpRemoveTagsFromVault) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2116 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2117) { 2118 request, ok := in.Request.(*smithyhttp.Request) 2119 if !ok { 2120 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2121 } 2122 2123 input, ok := in.Parameters.(*RemoveTagsFromVaultInput) 2124 _ = input 2125 if !ok { 2126 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2127 } 2128 2129 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/tags?operation=remove") 2130 request.URL.Path = opPath 2131 if len(request.URL.RawQuery) > 0 { 2132 request.URL.RawQuery = "&" + opQuery 2133 } else { 2134 request.URL.RawQuery = opQuery 2135 } 2136 2137 request.Method = "POST" 2138 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2139 if err != nil { 2140 return out, metadata, &smithy.SerializationError{Err: err} 2141 } 2142 2143 if err := awsRestjson1_serializeOpHttpBindingsRemoveTagsFromVaultInput(input, restEncoder); err != nil { 2144 return out, metadata, &smithy.SerializationError{Err: err} 2145 } 2146 2147 restEncoder.SetHeader("Content-Type").String("application/json") 2148 2149 jsonEncoder := smithyjson.NewEncoder() 2150 if err := awsRestjson1_serializeOpDocumentRemoveTagsFromVaultInput(input, jsonEncoder.Value); err != nil { 2151 return out, metadata, &smithy.SerializationError{Err: err} 2152 } 2153 2154 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2155 return out, metadata, &smithy.SerializationError{Err: err} 2156 } 2157 2158 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2159 return out, metadata, &smithy.SerializationError{Err: err} 2160 } 2161 in.Request = request 2162 2163 return next.HandleSerialize(ctx, in) 2164} 2165func awsRestjson1_serializeOpHttpBindingsRemoveTagsFromVaultInput(v *RemoveTagsFromVaultInput, encoder *httpbinding.Encoder) error { 2166 if v == nil { 2167 return fmt.Errorf("unsupported serialization of nil %T", v) 2168 } 2169 2170 if v.AccountId == nil || len(*v.AccountId) == 0 { 2171 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 2172 } 2173 if v.AccountId != nil { 2174 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 2175 return err 2176 } 2177 } 2178 2179 if v.VaultName == nil || len(*v.VaultName) == 0 { 2180 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 2181 } 2182 if v.VaultName != nil { 2183 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 2184 return err 2185 } 2186 } 2187 2188 return nil 2189} 2190 2191func awsRestjson1_serializeOpDocumentRemoveTagsFromVaultInput(v *RemoveTagsFromVaultInput, value smithyjson.Value) error { 2192 object := value.Object() 2193 defer object.Close() 2194 2195 if v.TagKeys != nil { 2196 ok := object.Key("TagKeys") 2197 if err := awsRestjson1_serializeDocumentTagKeyList(v.TagKeys, ok); err != nil { 2198 return err 2199 } 2200 } 2201 2202 return nil 2203} 2204 2205type awsRestjson1_serializeOpSetDataRetrievalPolicy struct { 2206} 2207 2208func (*awsRestjson1_serializeOpSetDataRetrievalPolicy) ID() string { 2209 return "OperationSerializer" 2210} 2211 2212func (m *awsRestjson1_serializeOpSetDataRetrievalPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2213 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2214) { 2215 request, ok := in.Request.(*smithyhttp.Request) 2216 if !ok { 2217 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2218 } 2219 2220 input, ok := in.Parameters.(*SetDataRetrievalPolicyInput) 2221 _ = input 2222 if !ok { 2223 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2224 } 2225 2226 opPath, opQuery := httpbinding.SplitURI("/{accountId}/policies/data-retrieval") 2227 request.URL.Path = opPath 2228 if len(request.URL.RawQuery) > 0 { 2229 request.URL.RawQuery = "&" + opQuery 2230 } else { 2231 request.URL.RawQuery = opQuery 2232 } 2233 2234 request.Method = "PUT" 2235 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2236 if err != nil { 2237 return out, metadata, &smithy.SerializationError{Err: err} 2238 } 2239 2240 if err := awsRestjson1_serializeOpHttpBindingsSetDataRetrievalPolicyInput(input, restEncoder); err != nil { 2241 return out, metadata, &smithy.SerializationError{Err: err} 2242 } 2243 2244 restEncoder.SetHeader("Content-Type").String("application/json") 2245 2246 jsonEncoder := smithyjson.NewEncoder() 2247 if err := awsRestjson1_serializeOpDocumentSetDataRetrievalPolicyInput(input, jsonEncoder.Value); err != nil { 2248 return out, metadata, &smithy.SerializationError{Err: err} 2249 } 2250 2251 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2252 return out, metadata, &smithy.SerializationError{Err: err} 2253 } 2254 2255 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2256 return out, metadata, &smithy.SerializationError{Err: err} 2257 } 2258 in.Request = request 2259 2260 return next.HandleSerialize(ctx, in) 2261} 2262func awsRestjson1_serializeOpHttpBindingsSetDataRetrievalPolicyInput(v *SetDataRetrievalPolicyInput, encoder *httpbinding.Encoder) error { 2263 if v == nil { 2264 return fmt.Errorf("unsupported serialization of nil %T", v) 2265 } 2266 2267 if v.AccountId == nil || len(*v.AccountId) == 0 { 2268 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 2269 } 2270 if v.AccountId != nil { 2271 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 2272 return err 2273 } 2274 } 2275 2276 return nil 2277} 2278 2279func awsRestjson1_serializeOpDocumentSetDataRetrievalPolicyInput(v *SetDataRetrievalPolicyInput, value smithyjson.Value) error { 2280 object := value.Object() 2281 defer object.Close() 2282 2283 if v.Policy != nil { 2284 ok := object.Key("Policy") 2285 if err := awsRestjson1_serializeDocumentDataRetrievalPolicy(v.Policy, ok); err != nil { 2286 return err 2287 } 2288 } 2289 2290 return nil 2291} 2292 2293type awsRestjson1_serializeOpSetVaultAccessPolicy struct { 2294} 2295 2296func (*awsRestjson1_serializeOpSetVaultAccessPolicy) ID() string { 2297 return "OperationSerializer" 2298} 2299 2300func (m *awsRestjson1_serializeOpSetVaultAccessPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2301 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2302) { 2303 request, ok := in.Request.(*smithyhttp.Request) 2304 if !ok { 2305 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2306 } 2307 2308 input, ok := in.Parameters.(*SetVaultAccessPolicyInput) 2309 _ = input 2310 if !ok { 2311 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2312 } 2313 2314 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/access-policy") 2315 request.URL.Path = opPath 2316 if len(request.URL.RawQuery) > 0 { 2317 request.URL.RawQuery = "&" + opQuery 2318 } else { 2319 request.URL.RawQuery = opQuery 2320 } 2321 2322 request.Method = "PUT" 2323 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2324 if err != nil { 2325 return out, metadata, &smithy.SerializationError{Err: err} 2326 } 2327 2328 if err := awsRestjson1_serializeOpHttpBindingsSetVaultAccessPolicyInput(input, restEncoder); err != nil { 2329 return out, metadata, &smithy.SerializationError{Err: err} 2330 } 2331 2332 if input.Policy != nil { 2333 if !restEncoder.HasHeader("Content-Type") { 2334 restEncoder.SetHeader("Content-Type").String("application/json") 2335 } 2336 2337 jsonEncoder := smithyjson.NewEncoder() 2338 if err := awsRestjson1_serializeDocumentVaultAccessPolicy(input.Policy, jsonEncoder.Value); err != nil { 2339 return out, metadata, &smithy.SerializationError{Err: err} 2340 } 2341 payload := bytes.NewReader(jsonEncoder.Bytes()) 2342 if request, err = request.SetStream(payload); err != nil { 2343 return out, metadata, &smithy.SerializationError{Err: err} 2344 } 2345 } 2346 2347 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2348 return out, metadata, &smithy.SerializationError{Err: err} 2349 } 2350 in.Request = request 2351 2352 return next.HandleSerialize(ctx, in) 2353} 2354func awsRestjson1_serializeOpHttpBindingsSetVaultAccessPolicyInput(v *SetVaultAccessPolicyInput, encoder *httpbinding.Encoder) error { 2355 if v == nil { 2356 return fmt.Errorf("unsupported serialization of nil %T", v) 2357 } 2358 2359 if v.AccountId == nil || len(*v.AccountId) == 0 { 2360 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 2361 } 2362 if v.AccountId != nil { 2363 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 2364 return err 2365 } 2366 } 2367 2368 if v.VaultName == nil || len(*v.VaultName) == 0 { 2369 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 2370 } 2371 if v.VaultName != nil { 2372 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 2373 return err 2374 } 2375 } 2376 2377 return nil 2378} 2379 2380type awsRestjson1_serializeOpSetVaultNotifications struct { 2381} 2382 2383func (*awsRestjson1_serializeOpSetVaultNotifications) ID() string { 2384 return "OperationSerializer" 2385} 2386 2387func (m *awsRestjson1_serializeOpSetVaultNotifications) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2388 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2389) { 2390 request, ok := in.Request.(*smithyhttp.Request) 2391 if !ok { 2392 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2393 } 2394 2395 input, ok := in.Parameters.(*SetVaultNotificationsInput) 2396 _ = input 2397 if !ok { 2398 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2399 } 2400 2401 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/notification-configuration") 2402 request.URL.Path = opPath 2403 if len(request.URL.RawQuery) > 0 { 2404 request.URL.RawQuery = "&" + opQuery 2405 } else { 2406 request.URL.RawQuery = opQuery 2407 } 2408 2409 request.Method = "PUT" 2410 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2411 if err != nil { 2412 return out, metadata, &smithy.SerializationError{Err: err} 2413 } 2414 2415 if err := awsRestjson1_serializeOpHttpBindingsSetVaultNotificationsInput(input, restEncoder); err != nil { 2416 return out, metadata, &smithy.SerializationError{Err: err} 2417 } 2418 2419 if input.VaultNotificationConfig != nil { 2420 if !restEncoder.HasHeader("Content-Type") { 2421 restEncoder.SetHeader("Content-Type").String("application/json") 2422 } 2423 2424 jsonEncoder := smithyjson.NewEncoder() 2425 if err := awsRestjson1_serializeDocumentVaultNotificationConfig(input.VaultNotificationConfig, jsonEncoder.Value); err != nil { 2426 return out, metadata, &smithy.SerializationError{Err: err} 2427 } 2428 payload := bytes.NewReader(jsonEncoder.Bytes()) 2429 if request, err = request.SetStream(payload); err != nil { 2430 return out, metadata, &smithy.SerializationError{Err: err} 2431 } 2432 } 2433 2434 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2435 return out, metadata, &smithy.SerializationError{Err: err} 2436 } 2437 in.Request = request 2438 2439 return next.HandleSerialize(ctx, in) 2440} 2441func awsRestjson1_serializeOpHttpBindingsSetVaultNotificationsInput(v *SetVaultNotificationsInput, encoder *httpbinding.Encoder) error { 2442 if v == nil { 2443 return fmt.Errorf("unsupported serialization of nil %T", v) 2444 } 2445 2446 if v.AccountId == nil || len(*v.AccountId) == 0 { 2447 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 2448 } 2449 if v.AccountId != nil { 2450 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 2451 return err 2452 } 2453 } 2454 2455 if v.VaultName == nil || len(*v.VaultName) == 0 { 2456 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 2457 } 2458 if v.VaultName != nil { 2459 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 2460 return err 2461 } 2462 } 2463 2464 return nil 2465} 2466 2467type awsRestjson1_serializeOpUploadArchive struct { 2468} 2469 2470func (*awsRestjson1_serializeOpUploadArchive) ID() string { 2471 return "OperationSerializer" 2472} 2473 2474func (m *awsRestjson1_serializeOpUploadArchive) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2475 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2476) { 2477 request, ok := in.Request.(*smithyhttp.Request) 2478 if !ok { 2479 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2480 } 2481 2482 input, ok := in.Parameters.(*UploadArchiveInput) 2483 _ = input 2484 if !ok { 2485 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2486 } 2487 2488 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/archives") 2489 request.URL.Path = opPath 2490 if len(request.URL.RawQuery) > 0 { 2491 request.URL.RawQuery = "&" + opQuery 2492 } else { 2493 request.URL.RawQuery = opQuery 2494 } 2495 2496 request.Method = "POST" 2497 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2498 if err != nil { 2499 return out, metadata, &smithy.SerializationError{Err: err} 2500 } 2501 2502 if err := awsRestjson1_serializeOpHttpBindingsUploadArchiveInput(input, restEncoder); err != nil { 2503 return out, metadata, &smithy.SerializationError{Err: err} 2504 } 2505 2506 if input.Body != nil { 2507 if !restEncoder.HasHeader("Content-Type") { 2508 restEncoder.SetHeader("Content-Type").String("application/octet-stream") 2509 } 2510 2511 payload := input.Body 2512 if request, err = request.SetStream(payload); err != nil { 2513 return out, metadata, &smithy.SerializationError{Err: err} 2514 } 2515 } 2516 2517 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2518 return out, metadata, &smithy.SerializationError{Err: err} 2519 } 2520 in.Request = request 2521 2522 return next.HandleSerialize(ctx, in) 2523} 2524func awsRestjson1_serializeOpHttpBindingsUploadArchiveInput(v *UploadArchiveInput, encoder *httpbinding.Encoder) error { 2525 if v == nil { 2526 return fmt.Errorf("unsupported serialization of nil %T", v) 2527 } 2528 2529 if v.AccountId == nil || len(*v.AccountId) == 0 { 2530 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 2531 } 2532 if v.AccountId != nil { 2533 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 2534 return err 2535 } 2536 } 2537 2538 if v.ArchiveDescription != nil && len(*v.ArchiveDescription) > 0 { 2539 locationName := "X-Amz-Archive-Description" 2540 encoder.SetHeader(locationName).String(*v.ArchiveDescription) 2541 } 2542 2543 if v.Checksum != nil && len(*v.Checksum) > 0 { 2544 locationName := "X-Amz-Sha256-Tree-Hash" 2545 encoder.SetHeader(locationName).String(*v.Checksum) 2546 } 2547 2548 if v.VaultName == nil || len(*v.VaultName) == 0 { 2549 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 2550 } 2551 if v.VaultName != nil { 2552 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 2553 return err 2554 } 2555 } 2556 2557 return nil 2558} 2559 2560type awsRestjson1_serializeOpUploadMultipartPart struct { 2561} 2562 2563func (*awsRestjson1_serializeOpUploadMultipartPart) ID() string { 2564 return "OperationSerializer" 2565} 2566 2567func (m *awsRestjson1_serializeOpUploadMultipartPart) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2568 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2569) { 2570 request, ok := in.Request.(*smithyhttp.Request) 2571 if !ok { 2572 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2573 } 2574 2575 input, ok := in.Parameters.(*UploadMultipartPartInput) 2576 _ = input 2577 if !ok { 2578 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2579 } 2580 2581 opPath, opQuery := httpbinding.SplitURI("/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}") 2582 request.URL.Path = opPath 2583 if len(request.URL.RawQuery) > 0 { 2584 request.URL.RawQuery = "&" + opQuery 2585 } else { 2586 request.URL.RawQuery = opQuery 2587 } 2588 2589 request.Method = "PUT" 2590 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2591 if err != nil { 2592 return out, metadata, &smithy.SerializationError{Err: err} 2593 } 2594 2595 if err := awsRestjson1_serializeOpHttpBindingsUploadMultipartPartInput(input, restEncoder); err != nil { 2596 return out, metadata, &smithy.SerializationError{Err: err} 2597 } 2598 2599 if input.Body != nil { 2600 if !restEncoder.HasHeader("Content-Type") { 2601 restEncoder.SetHeader("Content-Type").String("application/octet-stream") 2602 } 2603 2604 payload := input.Body 2605 if request, err = request.SetStream(payload); err != nil { 2606 return out, metadata, &smithy.SerializationError{Err: err} 2607 } 2608 } 2609 2610 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2611 return out, metadata, &smithy.SerializationError{Err: err} 2612 } 2613 in.Request = request 2614 2615 return next.HandleSerialize(ctx, in) 2616} 2617func awsRestjson1_serializeOpHttpBindingsUploadMultipartPartInput(v *UploadMultipartPartInput, encoder *httpbinding.Encoder) error { 2618 if v == nil { 2619 return fmt.Errorf("unsupported serialization of nil %T", v) 2620 } 2621 2622 if v.AccountId == nil || len(*v.AccountId) == 0 { 2623 return &smithy.SerializationError{Err: fmt.Errorf("input member accountId must not be empty")} 2624 } 2625 if v.AccountId != nil { 2626 if err := encoder.SetURI("accountId").String(*v.AccountId); err != nil { 2627 return err 2628 } 2629 } 2630 2631 if v.Checksum != nil && len(*v.Checksum) > 0 { 2632 locationName := "X-Amz-Sha256-Tree-Hash" 2633 encoder.SetHeader(locationName).String(*v.Checksum) 2634 } 2635 2636 if v.Range != nil && len(*v.Range) > 0 { 2637 locationName := "Content-Range" 2638 encoder.SetHeader(locationName).String(*v.Range) 2639 } 2640 2641 if v.UploadId == nil || len(*v.UploadId) == 0 { 2642 return &smithy.SerializationError{Err: fmt.Errorf("input member uploadId must not be empty")} 2643 } 2644 if v.UploadId != nil { 2645 if err := encoder.SetURI("uploadId").String(*v.UploadId); err != nil { 2646 return err 2647 } 2648 } 2649 2650 if v.VaultName == nil || len(*v.VaultName) == 0 { 2651 return &smithy.SerializationError{Err: fmt.Errorf("input member vaultName must not be empty")} 2652 } 2653 if v.VaultName != nil { 2654 if err := encoder.SetURI("vaultName").String(*v.VaultName); err != nil { 2655 return err 2656 } 2657 } 2658 2659 return nil 2660} 2661 2662func awsRestjson1_serializeDocumentAccessControlPolicyList(v []types.Grant, value smithyjson.Value) error { 2663 array := value.Array() 2664 defer array.Close() 2665 2666 for i := range v { 2667 av := array.Value() 2668 if err := awsRestjson1_serializeDocumentGrant(&v[i], av); err != nil { 2669 return err 2670 } 2671 } 2672 return nil 2673} 2674 2675func awsRestjson1_serializeDocumentCSVInput(v *types.CSVInput, value smithyjson.Value) error { 2676 object := value.Object() 2677 defer object.Close() 2678 2679 if v.Comments != nil { 2680 ok := object.Key("Comments") 2681 ok.String(*v.Comments) 2682 } 2683 2684 if v.FieldDelimiter != nil { 2685 ok := object.Key("FieldDelimiter") 2686 ok.String(*v.FieldDelimiter) 2687 } 2688 2689 if len(v.FileHeaderInfo) > 0 { 2690 ok := object.Key("FileHeaderInfo") 2691 ok.String(string(v.FileHeaderInfo)) 2692 } 2693 2694 if v.QuoteCharacter != nil { 2695 ok := object.Key("QuoteCharacter") 2696 ok.String(*v.QuoteCharacter) 2697 } 2698 2699 if v.QuoteEscapeCharacter != nil { 2700 ok := object.Key("QuoteEscapeCharacter") 2701 ok.String(*v.QuoteEscapeCharacter) 2702 } 2703 2704 if v.RecordDelimiter != nil { 2705 ok := object.Key("RecordDelimiter") 2706 ok.String(*v.RecordDelimiter) 2707 } 2708 2709 return nil 2710} 2711 2712func awsRestjson1_serializeDocumentCSVOutput(v *types.CSVOutput, value smithyjson.Value) error { 2713 object := value.Object() 2714 defer object.Close() 2715 2716 if v.FieldDelimiter != nil { 2717 ok := object.Key("FieldDelimiter") 2718 ok.String(*v.FieldDelimiter) 2719 } 2720 2721 if v.QuoteCharacter != nil { 2722 ok := object.Key("QuoteCharacter") 2723 ok.String(*v.QuoteCharacter) 2724 } 2725 2726 if v.QuoteEscapeCharacter != nil { 2727 ok := object.Key("QuoteEscapeCharacter") 2728 ok.String(*v.QuoteEscapeCharacter) 2729 } 2730 2731 if len(v.QuoteFields) > 0 { 2732 ok := object.Key("QuoteFields") 2733 ok.String(string(v.QuoteFields)) 2734 } 2735 2736 if v.RecordDelimiter != nil { 2737 ok := object.Key("RecordDelimiter") 2738 ok.String(*v.RecordDelimiter) 2739 } 2740 2741 return nil 2742} 2743 2744func awsRestjson1_serializeDocumentDataRetrievalPolicy(v *types.DataRetrievalPolicy, value smithyjson.Value) error { 2745 object := value.Object() 2746 defer object.Close() 2747 2748 if v.Rules != nil { 2749 ok := object.Key("Rules") 2750 if err := awsRestjson1_serializeDocumentDataRetrievalRulesList(v.Rules, ok); err != nil { 2751 return err 2752 } 2753 } 2754 2755 return nil 2756} 2757 2758func awsRestjson1_serializeDocumentDataRetrievalRule(v *types.DataRetrievalRule, value smithyjson.Value) error { 2759 object := value.Object() 2760 defer object.Close() 2761 2762 if v.BytesPerHour != nil { 2763 ok := object.Key("BytesPerHour") 2764 ok.Long(*v.BytesPerHour) 2765 } 2766 2767 if v.Strategy != nil { 2768 ok := object.Key("Strategy") 2769 ok.String(*v.Strategy) 2770 } 2771 2772 return nil 2773} 2774 2775func awsRestjson1_serializeDocumentDataRetrievalRulesList(v []types.DataRetrievalRule, value smithyjson.Value) error { 2776 array := value.Array() 2777 defer array.Close() 2778 2779 for i := range v { 2780 av := array.Value() 2781 if err := awsRestjson1_serializeDocumentDataRetrievalRule(&v[i], av); err != nil { 2782 return err 2783 } 2784 } 2785 return nil 2786} 2787 2788func awsRestjson1_serializeDocumentEncryption(v *types.Encryption, value smithyjson.Value) error { 2789 object := value.Object() 2790 defer object.Close() 2791 2792 if len(v.EncryptionType) > 0 { 2793 ok := object.Key("EncryptionType") 2794 ok.String(string(v.EncryptionType)) 2795 } 2796 2797 if v.KMSContext != nil { 2798 ok := object.Key("KMSContext") 2799 ok.String(*v.KMSContext) 2800 } 2801 2802 if v.KMSKeyId != nil { 2803 ok := object.Key("KMSKeyId") 2804 ok.String(*v.KMSKeyId) 2805 } 2806 2807 return nil 2808} 2809 2810func awsRestjson1_serializeDocumentGrant(v *types.Grant, value smithyjson.Value) error { 2811 object := value.Object() 2812 defer object.Close() 2813 2814 if v.Grantee != nil { 2815 ok := object.Key("Grantee") 2816 if err := awsRestjson1_serializeDocumentGrantee(v.Grantee, ok); err != nil { 2817 return err 2818 } 2819 } 2820 2821 if len(v.Permission) > 0 { 2822 ok := object.Key("Permission") 2823 ok.String(string(v.Permission)) 2824 } 2825 2826 return nil 2827} 2828 2829func awsRestjson1_serializeDocumentGrantee(v *types.Grantee, value smithyjson.Value) error { 2830 object := value.Object() 2831 defer object.Close() 2832 2833 if v.DisplayName != nil { 2834 ok := object.Key("DisplayName") 2835 ok.String(*v.DisplayName) 2836 } 2837 2838 if v.EmailAddress != nil { 2839 ok := object.Key("EmailAddress") 2840 ok.String(*v.EmailAddress) 2841 } 2842 2843 if v.ID != nil { 2844 ok := object.Key("ID") 2845 ok.String(*v.ID) 2846 } 2847 2848 if len(v.Type) > 0 { 2849 ok := object.Key("Type") 2850 ok.String(string(v.Type)) 2851 } 2852 2853 if v.URI != nil { 2854 ok := object.Key("URI") 2855 ok.String(*v.URI) 2856 } 2857 2858 return nil 2859} 2860 2861func awsRestjson1_serializeDocumentHashmap(v map[string]string, value smithyjson.Value) error { 2862 object := value.Object() 2863 defer object.Close() 2864 2865 for key := range v { 2866 om := object.Key(key) 2867 om.String(v[key]) 2868 } 2869 return nil 2870} 2871 2872func awsRestjson1_serializeDocumentInputSerialization(v *types.InputSerialization, value smithyjson.Value) error { 2873 object := value.Object() 2874 defer object.Close() 2875 2876 if v.Csv != nil { 2877 ok := object.Key("csv") 2878 if err := awsRestjson1_serializeDocumentCSVInput(v.Csv, ok); err != nil { 2879 return err 2880 } 2881 } 2882 2883 return nil 2884} 2885 2886func awsRestjson1_serializeDocumentInventoryRetrievalJobInput(v *types.InventoryRetrievalJobInput, value smithyjson.Value) error { 2887 object := value.Object() 2888 defer object.Close() 2889 2890 if v.EndDate != nil { 2891 ok := object.Key("EndDate") 2892 ok.String(*v.EndDate) 2893 } 2894 2895 if v.Limit != nil { 2896 ok := object.Key("Limit") 2897 ok.String(*v.Limit) 2898 } 2899 2900 if v.Marker != nil { 2901 ok := object.Key("Marker") 2902 ok.String(*v.Marker) 2903 } 2904 2905 if v.StartDate != nil { 2906 ok := object.Key("StartDate") 2907 ok.String(*v.StartDate) 2908 } 2909 2910 return nil 2911} 2912 2913func awsRestjson1_serializeDocumentJobParameters(v *types.JobParameters, value smithyjson.Value) error { 2914 object := value.Object() 2915 defer object.Close() 2916 2917 if v.ArchiveId != nil { 2918 ok := object.Key("ArchiveId") 2919 ok.String(*v.ArchiveId) 2920 } 2921 2922 if v.Description != nil { 2923 ok := object.Key("Description") 2924 ok.String(*v.Description) 2925 } 2926 2927 if v.Format != nil { 2928 ok := object.Key("Format") 2929 ok.String(*v.Format) 2930 } 2931 2932 if v.InventoryRetrievalParameters != nil { 2933 ok := object.Key("InventoryRetrievalParameters") 2934 if err := awsRestjson1_serializeDocumentInventoryRetrievalJobInput(v.InventoryRetrievalParameters, ok); err != nil { 2935 return err 2936 } 2937 } 2938 2939 if v.OutputLocation != nil { 2940 ok := object.Key("OutputLocation") 2941 if err := awsRestjson1_serializeDocumentOutputLocation(v.OutputLocation, ok); err != nil { 2942 return err 2943 } 2944 } 2945 2946 if v.RetrievalByteRange != nil { 2947 ok := object.Key("RetrievalByteRange") 2948 ok.String(*v.RetrievalByteRange) 2949 } 2950 2951 if v.SelectParameters != nil { 2952 ok := object.Key("SelectParameters") 2953 if err := awsRestjson1_serializeDocumentSelectParameters(v.SelectParameters, ok); err != nil { 2954 return err 2955 } 2956 } 2957 2958 if v.SNSTopic != nil { 2959 ok := object.Key("SNSTopic") 2960 ok.String(*v.SNSTopic) 2961 } 2962 2963 if v.Tier != nil { 2964 ok := object.Key("Tier") 2965 ok.String(*v.Tier) 2966 } 2967 2968 if v.Type != nil { 2969 ok := object.Key("Type") 2970 ok.String(*v.Type) 2971 } 2972 2973 return nil 2974} 2975 2976func awsRestjson1_serializeDocumentNotificationEventList(v []string, value smithyjson.Value) error { 2977 array := value.Array() 2978 defer array.Close() 2979 2980 for i := range v { 2981 av := array.Value() 2982 av.String(v[i]) 2983 } 2984 return nil 2985} 2986 2987func awsRestjson1_serializeDocumentOutputLocation(v *types.OutputLocation, value smithyjson.Value) error { 2988 object := value.Object() 2989 defer object.Close() 2990 2991 if v.S3 != nil { 2992 ok := object.Key("S3") 2993 if err := awsRestjson1_serializeDocumentS3Location(v.S3, ok); err != nil { 2994 return err 2995 } 2996 } 2997 2998 return nil 2999} 3000 3001func awsRestjson1_serializeDocumentOutputSerialization(v *types.OutputSerialization, value smithyjson.Value) error { 3002 object := value.Object() 3003 defer object.Close() 3004 3005 if v.Csv != nil { 3006 ok := object.Key("csv") 3007 if err := awsRestjson1_serializeDocumentCSVOutput(v.Csv, ok); err != nil { 3008 return err 3009 } 3010 } 3011 3012 return nil 3013} 3014 3015func awsRestjson1_serializeDocumentS3Location(v *types.S3Location, value smithyjson.Value) error { 3016 object := value.Object() 3017 defer object.Close() 3018 3019 if v.AccessControlList != nil { 3020 ok := object.Key("AccessControlList") 3021 if err := awsRestjson1_serializeDocumentAccessControlPolicyList(v.AccessControlList, ok); err != nil { 3022 return err 3023 } 3024 } 3025 3026 if v.BucketName != nil { 3027 ok := object.Key("BucketName") 3028 ok.String(*v.BucketName) 3029 } 3030 3031 if len(v.CannedACL) > 0 { 3032 ok := object.Key("CannedACL") 3033 ok.String(string(v.CannedACL)) 3034 } 3035 3036 if v.Encryption != nil { 3037 ok := object.Key("Encryption") 3038 if err := awsRestjson1_serializeDocumentEncryption(v.Encryption, ok); err != nil { 3039 return err 3040 } 3041 } 3042 3043 if v.Prefix != nil { 3044 ok := object.Key("Prefix") 3045 ok.String(*v.Prefix) 3046 } 3047 3048 if len(v.StorageClass) > 0 { 3049 ok := object.Key("StorageClass") 3050 ok.String(string(v.StorageClass)) 3051 } 3052 3053 if v.Tagging != nil { 3054 ok := object.Key("Tagging") 3055 if err := awsRestjson1_serializeDocumentHashmap(v.Tagging, ok); err != nil { 3056 return err 3057 } 3058 } 3059 3060 if v.UserMetadata != nil { 3061 ok := object.Key("UserMetadata") 3062 if err := awsRestjson1_serializeDocumentHashmap(v.UserMetadata, ok); err != nil { 3063 return err 3064 } 3065 } 3066 3067 return nil 3068} 3069 3070func awsRestjson1_serializeDocumentSelectParameters(v *types.SelectParameters, value smithyjson.Value) error { 3071 object := value.Object() 3072 defer object.Close() 3073 3074 if v.Expression != nil { 3075 ok := object.Key("Expression") 3076 ok.String(*v.Expression) 3077 } 3078 3079 if len(v.ExpressionType) > 0 { 3080 ok := object.Key("ExpressionType") 3081 ok.String(string(v.ExpressionType)) 3082 } 3083 3084 if v.InputSerialization != nil { 3085 ok := object.Key("InputSerialization") 3086 if err := awsRestjson1_serializeDocumentInputSerialization(v.InputSerialization, ok); err != nil { 3087 return err 3088 } 3089 } 3090 3091 if v.OutputSerialization != nil { 3092 ok := object.Key("OutputSerialization") 3093 if err := awsRestjson1_serializeDocumentOutputSerialization(v.OutputSerialization, ok); err != nil { 3094 return err 3095 } 3096 } 3097 3098 return nil 3099} 3100 3101func awsRestjson1_serializeDocumentTagKeyList(v []string, value smithyjson.Value) error { 3102 array := value.Array() 3103 defer array.Close() 3104 3105 for i := range v { 3106 av := array.Value() 3107 av.String(v[i]) 3108 } 3109 return nil 3110} 3111 3112func awsRestjson1_serializeDocumentTagMap(v map[string]string, value smithyjson.Value) error { 3113 object := value.Object() 3114 defer object.Close() 3115 3116 for key := range v { 3117 om := object.Key(key) 3118 om.String(v[key]) 3119 } 3120 return nil 3121} 3122 3123func awsRestjson1_serializeDocumentVaultAccessPolicy(v *types.VaultAccessPolicy, value smithyjson.Value) error { 3124 object := value.Object() 3125 defer object.Close() 3126 3127 if v.Policy != nil { 3128 ok := object.Key("Policy") 3129 ok.String(*v.Policy) 3130 } 3131 3132 return nil 3133} 3134 3135func awsRestjson1_serializeDocumentVaultLockPolicy(v *types.VaultLockPolicy, value smithyjson.Value) error { 3136 object := value.Object() 3137 defer object.Close() 3138 3139 if v.Policy != nil { 3140 ok := object.Key("Policy") 3141 ok.String(*v.Policy) 3142 } 3143 3144 return nil 3145} 3146 3147func awsRestjson1_serializeDocumentVaultNotificationConfig(v *types.VaultNotificationConfig, value smithyjson.Value) error { 3148 object := value.Object() 3149 defer object.Close() 3150 3151 if v.Events != nil { 3152 ok := object.Key("Events") 3153 if err := awsRestjson1_serializeDocumentNotificationEventList(v.Events, ok); err != nil { 3154 return err 3155 } 3156 } 3157 3158 if v.SNSTopic != nil { 3159 ok := object.Key("SNSTopic") 3160 ok.String(*v.SNSTopic) 3161 } 3162 3163 return nil 3164} 3165