1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package route53domains 4 5import ( 6 "bytes" 7 "context" 8 "encoding/json" 9 "fmt" 10 "github.com/aws/aws-sdk-go-v2/aws/protocol/restjson" 11 "github.com/aws/aws-sdk-go-v2/service/route53domains/types" 12 smithy "github.com/aws/smithy-go" 13 smithyio "github.com/aws/smithy-go/io" 14 "github.com/aws/smithy-go/middleware" 15 "github.com/aws/smithy-go/ptr" 16 smithytime "github.com/aws/smithy-go/time" 17 smithyhttp "github.com/aws/smithy-go/transport/http" 18 "io" 19 "strings" 20) 21 22type awsAwsjson11_deserializeOpAcceptDomainTransferFromAnotherAwsAccount struct { 23} 24 25func (*awsAwsjson11_deserializeOpAcceptDomainTransferFromAnotherAwsAccount) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsAwsjson11_deserializeOpAcceptDomainTransferFromAnotherAwsAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 30 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 31) { 32 out, metadata, err = next.HandleDeserialize(ctx, in) 33 if err != nil { 34 return out, metadata, err 35 } 36 37 response, ok := out.RawResponse.(*smithyhttp.Response) 38 if !ok { 39 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 40 } 41 42 if response.StatusCode < 200 || response.StatusCode >= 300 { 43 return out, metadata, awsAwsjson11_deserializeOpErrorAcceptDomainTransferFromAnotherAwsAccount(response, &metadata) 44 } 45 output := &AcceptDomainTransferFromAnotherAwsAccountOutput{} 46 out.Result = output 47 48 var buff [1024]byte 49 ringBuffer := smithyio.NewRingBuffer(buff[:]) 50 51 body := io.TeeReader(response.Body, ringBuffer) 52 decoder := json.NewDecoder(body) 53 decoder.UseNumber() 54 var shape interface{} 55 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 56 var snapshot bytes.Buffer 57 io.Copy(&snapshot, ringBuffer) 58 err = &smithy.DeserializationError{ 59 Err: fmt.Errorf("failed to decode response body, %w", err), 60 Snapshot: snapshot.Bytes(), 61 } 62 return out, metadata, err 63 } 64 65 err = awsAwsjson11_deserializeOpDocumentAcceptDomainTransferFromAnotherAwsAccountOutput(&output, shape) 66 if err != nil { 67 var snapshot bytes.Buffer 68 io.Copy(&snapshot, ringBuffer) 69 err = &smithy.DeserializationError{ 70 Err: fmt.Errorf("failed to decode response body, %w", err), 71 Snapshot: snapshot.Bytes(), 72 } 73 return out, metadata, err 74 } 75 76 return out, metadata, err 77} 78 79func awsAwsjson11_deserializeOpErrorAcceptDomainTransferFromAnotherAwsAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 80 var errorBuffer bytes.Buffer 81 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 82 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 83 } 84 errorBody := bytes.NewReader(errorBuffer.Bytes()) 85 86 errorCode := "UnknownError" 87 errorMessage := errorCode 88 89 code := response.Header.Get("X-Amzn-ErrorType") 90 if len(code) != 0 { 91 errorCode = restjson.SanitizeErrorCode(code) 92 } 93 94 var buff [1024]byte 95 ringBuffer := smithyio.NewRingBuffer(buff[:]) 96 97 body := io.TeeReader(errorBody, ringBuffer) 98 decoder := json.NewDecoder(body) 99 decoder.UseNumber() 100 code, message, err := restjson.GetErrorInfo(decoder) 101 if err != nil { 102 var snapshot bytes.Buffer 103 io.Copy(&snapshot, ringBuffer) 104 err = &smithy.DeserializationError{ 105 Err: fmt.Errorf("failed to decode response body, %w", err), 106 Snapshot: snapshot.Bytes(), 107 } 108 return err 109 } 110 111 errorBody.Seek(0, io.SeekStart) 112 if len(code) != 0 { 113 errorCode = restjson.SanitizeErrorCode(code) 114 } 115 if len(message) != 0 { 116 errorMessage = message 117 } 118 119 switch { 120 case strings.EqualFold("DomainLimitExceeded", errorCode): 121 return awsAwsjson11_deserializeErrorDomainLimitExceeded(response, errorBody) 122 123 case strings.EqualFold("InvalidInput", errorCode): 124 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 125 126 case strings.EqualFold("OperationLimitExceeded", errorCode): 127 return awsAwsjson11_deserializeErrorOperationLimitExceeded(response, errorBody) 128 129 default: 130 genericError := &smithy.GenericAPIError{ 131 Code: errorCode, 132 Message: errorMessage, 133 } 134 return genericError 135 136 } 137} 138 139type awsAwsjson11_deserializeOpCancelDomainTransferToAnotherAwsAccount struct { 140} 141 142func (*awsAwsjson11_deserializeOpCancelDomainTransferToAnotherAwsAccount) ID() string { 143 return "OperationDeserializer" 144} 145 146func (m *awsAwsjson11_deserializeOpCancelDomainTransferToAnotherAwsAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 147 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 148) { 149 out, metadata, err = next.HandleDeserialize(ctx, in) 150 if err != nil { 151 return out, metadata, err 152 } 153 154 response, ok := out.RawResponse.(*smithyhttp.Response) 155 if !ok { 156 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 157 } 158 159 if response.StatusCode < 200 || response.StatusCode >= 300 { 160 return out, metadata, awsAwsjson11_deserializeOpErrorCancelDomainTransferToAnotherAwsAccount(response, &metadata) 161 } 162 output := &CancelDomainTransferToAnotherAwsAccountOutput{} 163 out.Result = output 164 165 var buff [1024]byte 166 ringBuffer := smithyio.NewRingBuffer(buff[:]) 167 168 body := io.TeeReader(response.Body, ringBuffer) 169 decoder := json.NewDecoder(body) 170 decoder.UseNumber() 171 var shape interface{} 172 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 173 var snapshot bytes.Buffer 174 io.Copy(&snapshot, ringBuffer) 175 err = &smithy.DeserializationError{ 176 Err: fmt.Errorf("failed to decode response body, %w", err), 177 Snapshot: snapshot.Bytes(), 178 } 179 return out, metadata, err 180 } 181 182 err = awsAwsjson11_deserializeOpDocumentCancelDomainTransferToAnotherAwsAccountOutput(&output, shape) 183 if err != nil { 184 var snapshot bytes.Buffer 185 io.Copy(&snapshot, ringBuffer) 186 err = &smithy.DeserializationError{ 187 Err: fmt.Errorf("failed to decode response body, %w", err), 188 Snapshot: snapshot.Bytes(), 189 } 190 return out, metadata, err 191 } 192 193 return out, metadata, err 194} 195 196func awsAwsjson11_deserializeOpErrorCancelDomainTransferToAnotherAwsAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 197 var errorBuffer bytes.Buffer 198 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 199 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 200 } 201 errorBody := bytes.NewReader(errorBuffer.Bytes()) 202 203 errorCode := "UnknownError" 204 errorMessage := errorCode 205 206 code := response.Header.Get("X-Amzn-ErrorType") 207 if len(code) != 0 { 208 errorCode = restjson.SanitizeErrorCode(code) 209 } 210 211 var buff [1024]byte 212 ringBuffer := smithyio.NewRingBuffer(buff[:]) 213 214 body := io.TeeReader(errorBody, ringBuffer) 215 decoder := json.NewDecoder(body) 216 decoder.UseNumber() 217 code, message, err := restjson.GetErrorInfo(decoder) 218 if err != nil { 219 var snapshot bytes.Buffer 220 io.Copy(&snapshot, ringBuffer) 221 err = &smithy.DeserializationError{ 222 Err: fmt.Errorf("failed to decode response body, %w", err), 223 Snapshot: snapshot.Bytes(), 224 } 225 return err 226 } 227 228 errorBody.Seek(0, io.SeekStart) 229 if len(code) != 0 { 230 errorCode = restjson.SanitizeErrorCode(code) 231 } 232 if len(message) != 0 { 233 errorMessage = message 234 } 235 236 switch { 237 case strings.EqualFold("InvalidInput", errorCode): 238 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 239 240 case strings.EqualFold("OperationLimitExceeded", errorCode): 241 return awsAwsjson11_deserializeErrorOperationLimitExceeded(response, errorBody) 242 243 default: 244 genericError := &smithy.GenericAPIError{ 245 Code: errorCode, 246 Message: errorMessage, 247 } 248 return genericError 249 250 } 251} 252 253type awsAwsjson11_deserializeOpCheckDomainAvailability struct { 254} 255 256func (*awsAwsjson11_deserializeOpCheckDomainAvailability) ID() string { 257 return "OperationDeserializer" 258} 259 260func (m *awsAwsjson11_deserializeOpCheckDomainAvailability) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 261 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 262) { 263 out, metadata, err = next.HandleDeserialize(ctx, in) 264 if err != nil { 265 return out, metadata, err 266 } 267 268 response, ok := out.RawResponse.(*smithyhttp.Response) 269 if !ok { 270 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 271 } 272 273 if response.StatusCode < 200 || response.StatusCode >= 300 { 274 return out, metadata, awsAwsjson11_deserializeOpErrorCheckDomainAvailability(response, &metadata) 275 } 276 output := &CheckDomainAvailabilityOutput{} 277 out.Result = output 278 279 var buff [1024]byte 280 ringBuffer := smithyio.NewRingBuffer(buff[:]) 281 282 body := io.TeeReader(response.Body, ringBuffer) 283 decoder := json.NewDecoder(body) 284 decoder.UseNumber() 285 var shape interface{} 286 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 287 var snapshot bytes.Buffer 288 io.Copy(&snapshot, ringBuffer) 289 err = &smithy.DeserializationError{ 290 Err: fmt.Errorf("failed to decode response body, %w", err), 291 Snapshot: snapshot.Bytes(), 292 } 293 return out, metadata, err 294 } 295 296 err = awsAwsjson11_deserializeOpDocumentCheckDomainAvailabilityOutput(&output, shape) 297 if err != nil { 298 var snapshot bytes.Buffer 299 io.Copy(&snapshot, ringBuffer) 300 err = &smithy.DeserializationError{ 301 Err: fmt.Errorf("failed to decode response body, %w", err), 302 Snapshot: snapshot.Bytes(), 303 } 304 return out, metadata, err 305 } 306 307 return out, metadata, err 308} 309 310func awsAwsjson11_deserializeOpErrorCheckDomainAvailability(response *smithyhttp.Response, metadata *middleware.Metadata) error { 311 var errorBuffer bytes.Buffer 312 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 313 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 314 } 315 errorBody := bytes.NewReader(errorBuffer.Bytes()) 316 317 errorCode := "UnknownError" 318 errorMessage := errorCode 319 320 code := response.Header.Get("X-Amzn-ErrorType") 321 if len(code) != 0 { 322 errorCode = restjson.SanitizeErrorCode(code) 323 } 324 325 var buff [1024]byte 326 ringBuffer := smithyio.NewRingBuffer(buff[:]) 327 328 body := io.TeeReader(errorBody, ringBuffer) 329 decoder := json.NewDecoder(body) 330 decoder.UseNumber() 331 code, message, err := restjson.GetErrorInfo(decoder) 332 if err != nil { 333 var snapshot bytes.Buffer 334 io.Copy(&snapshot, ringBuffer) 335 err = &smithy.DeserializationError{ 336 Err: fmt.Errorf("failed to decode response body, %w", err), 337 Snapshot: snapshot.Bytes(), 338 } 339 return err 340 } 341 342 errorBody.Seek(0, io.SeekStart) 343 if len(code) != 0 { 344 errorCode = restjson.SanitizeErrorCode(code) 345 } 346 if len(message) != 0 { 347 errorMessage = message 348 } 349 350 switch { 351 case strings.EqualFold("InvalidInput", errorCode): 352 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 353 354 case strings.EqualFold("UnsupportedTLD", errorCode): 355 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 356 357 default: 358 genericError := &smithy.GenericAPIError{ 359 Code: errorCode, 360 Message: errorMessage, 361 } 362 return genericError 363 364 } 365} 366 367type awsAwsjson11_deserializeOpCheckDomainTransferability struct { 368} 369 370func (*awsAwsjson11_deserializeOpCheckDomainTransferability) ID() string { 371 return "OperationDeserializer" 372} 373 374func (m *awsAwsjson11_deserializeOpCheckDomainTransferability) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 375 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 376) { 377 out, metadata, err = next.HandleDeserialize(ctx, in) 378 if err != nil { 379 return out, metadata, err 380 } 381 382 response, ok := out.RawResponse.(*smithyhttp.Response) 383 if !ok { 384 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 385 } 386 387 if response.StatusCode < 200 || response.StatusCode >= 300 { 388 return out, metadata, awsAwsjson11_deserializeOpErrorCheckDomainTransferability(response, &metadata) 389 } 390 output := &CheckDomainTransferabilityOutput{} 391 out.Result = output 392 393 var buff [1024]byte 394 ringBuffer := smithyio.NewRingBuffer(buff[:]) 395 396 body := io.TeeReader(response.Body, ringBuffer) 397 decoder := json.NewDecoder(body) 398 decoder.UseNumber() 399 var shape interface{} 400 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 401 var snapshot bytes.Buffer 402 io.Copy(&snapshot, ringBuffer) 403 err = &smithy.DeserializationError{ 404 Err: fmt.Errorf("failed to decode response body, %w", err), 405 Snapshot: snapshot.Bytes(), 406 } 407 return out, metadata, err 408 } 409 410 err = awsAwsjson11_deserializeOpDocumentCheckDomainTransferabilityOutput(&output, shape) 411 if err != nil { 412 var snapshot bytes.Buffer 413 io.Copy(&snapshot, ringBuffer) 414 err = &smithy.DeserializationError{ 415 Err: fmt.Errorf("failed to decode response body, %w", err), 416 Snapshot: snapshot.Bytes(), 417 } 418 return out, metadata, err 419 } 420 421 return out, metadata, err 422} 423 424func awsAwsjson11_deserializeOpErrorCheckDomainTransferability(response *smithyhttp.Response, metadata *middleware.Metadata) error { 425 var errorBuffer bytes.Buffer 426 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 427 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 428 } 429 errorBody := bytes.NewReader(errorBuffer.Bytes()) 430 431 errorCode := "UnknownError" 432 errorMessage := errorCode 433 434 code := response.Header.Get("X-Amzn-ErrorType") 435 if len(code) != 0 { 436 errorCode = restjson.SanitizeErrorCode(code) 437 } 438 439 var buff [1024]byte 440 ringBuffer := smithyio.NewRingBuffer(buff[:]) 441 442 body := io.TeeReader(errorBody, ringBuffer) 443 decoder := json.NewDecoder(body) 444 decoder.UseNumber() 445 code, message, err := restjson.GetErrorInfo(decoder) 446 if err != nil { 447 var snapshot bytes.Buffer 448 io.Copy(&snapshot, ringBuffer) 449 err = &smithy.DeserializationError{ 450 Err: fmt.Errorf("failed to decode response body, %w", err), 451 Snapshot: snapshot.Bytes(), 452 } 453 return err 454 } 455 456 errorBody.Seek(0, io.SeekStart) 457 if len(code) != 0 { 458 errorCode = restjson.SanitizeErrorCode(code) 459 } 460 if len(message) != 0 { 461 errorMessage = message 462 } 463 464 switch { 465 case strings.EqualFold("InvalidInput", errorCode): 466 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 467 468 case strings.EqualFold("UnsupportedTLD", errorCode): 469 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 470 471 default: 472 genericError := &smithy.GenericAPIError{ 473 Code: errorCode, 474 Message: errorMessage, 475 } 476 return genericError 477 478 } 479} 480 481type awsAwsjson11_deserializeOpDeleteTagsForDomain struct { 482} 483 484func (*awsAwsjson11_deserializeOpDeleteTagsForDomain) ID() string { 485 return "OperationDeserializer" 486} 487 488func (m *awsAwsjson11_deserializeOpDeleteTagsForDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 489 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 490) { 491 out, metadata, err = next.HandleDeserialize(ctx, in) 492 if err != nil { 493 return out, metadata, err 494 } 495 496 response, ok := out.RawResponse.(*smithyhttp.Response) 497 if !ok { 498 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 499 } 500 501 if response.StatusCode < 200 || response.StatusCode >= 300 { 502 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteTagsForDomain(response, &metadata) 503 } 504 output := &DeleteTagsForDomainOutput{} 505 out.Result = output 506 507 var buff [1024]byte 508 ringBuffer := smithyio.NewRingBuffer(buff[:]) 509 510 body := io.TeeReader(response.Body, ringBuffer) 511 decoder := json.NewDecoder(body) 512 decoder.UseNumber() 513 var shape interface{} 514 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 515 var snapshot bytes.Buffer 516 io.Copy(&snapshot, ringBuffer) 517 err = &smithy.DeserializationError{ 518 Err: fmt.Errorf("failed to decode response body, %w", err), 519 Snapshot: snapshot.Bytes(), 520 } 521 return out, metadata, err 522 } 523 524 err = awsAwsjson11_deserializeOpDocumentDeleteTagsForDomainOutput(&output, shape) 525 if err != nil { 526 var snapshot bytes.Buffer 527 io.Copy(&snapshot, ringBuffer) 528 err = &smithy.DeserializationError{ 529 Err: fmt.Errorf("failed to decode response body, %w", err), 530 Snapshot: snapshot.Bytes(), 531 } 532 return out, metadata, err 533 } 534 535 return out, metadata, err 536} 537 538func awsAwsjson11_deserializeOpErrorDeleteTagsForDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { 539 var errorBuffer bytes.Buffer 540 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 541 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 542 } 543 errorBody := bytes.NewReader(errorBuffer.Bytes()) 544 545 errorCode := "UnknownError" 546 errorMessage := errorCode 547 548 code := response.Header.Get("X-Amzn-ErrorType") 549 if len(code) != 0 { 550 errorCode = restjson.SanitizeErrorCode(code) 551 } 552 553 var buff [1024]byte 554 ringBuffer := smithyio.NewRingBuffer(buff[:]) 555 556 body := io.TeeReader(errorBody, ringBuffer) 557 decoder := json.NewDecoder(body) 558 decoder.UseNumber() 559 code, message, err := restjson.GetErrorInfo(decoder) 560 if err != nil { 561 var snapshot bytes.Buffer 562 io.Copy(&snapshot, ringBuffer) 563 err = &smithy.DeserializationError{ 564 Err: fmt.Errorf("failed to decode response body, %w", err), 565 Snapshot: snapshot.Bytes(), 566 } 567 return err 568 } 569 570 errorBody.Seek(0, io.SeekStart) 571 if len(code) != 0 { 572 errorCode = restjson.SanitizeErrorCode(code) 573 } 574 if len(message) != 0 { 575 errorMessage = message 576 } 577 578 switch { 579 case strings.EqualFold("InvalidInput", errorCode): 580 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 581 582 case strings.EqualFold("OperationLimitExceeded", errorCode): 583 return awsAwsjson11_deserializeErrorOperationLimitExceeded(response, errorBody) 584 585 case strings.EqualFold("UnsupportedTLD", errorCode): 586 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 587 588 default: 589 genericError := &smithy.GenericAPIError{ 590 Code: errorCode, 591 Message: errorMessage, 592 } 593 return genericError 594 595 } 596} 597 598type awsAwsjson11_deserializeOpDisableDomainAutoRenew struct { 599} 600 601func (*awsAwsjson11_deserializeOpDisableDomainAutoRenew) ID() string { 602 return "OperationDeserializer" 603} 604 605func (m *awsAwsjson11_deserializeOpDisableDomainAutoRenew) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 606 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 607) { 608 out, metadata, err = next.HandleDeserialize(ctx, in) 609 if err != nil { 610 return out, metadata, err 611 } 612 613 response, ok := out.RawResponse.(*smithyhttp.Response) 614 if !ok { 615 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 616 } 617 618 if response.StatusCode < 200 || response.StatusCode >= 300 { 619 return out, metadata, awsAwsjson11_deserializeOpErrorDisableDomainAutoRenew(response, &metadata) 620 } 621 output := &DisableDomainAutoRenewOutput{} 622 out.Result = output 623 624 var buff [1024]byte 625 ringBuffer := smithyio.NewRingBuffer(buff[:]) 626 627 body := io.TeeReader(response.Body, ringBuffer) 628 decoder := json.NewDecoder(body) 629 decoder.UseNumber() 630 var shape interface{} 631 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 632 var snapshot bytes.Buffer 633 io.Copy(&snapshot, ringBuffer) 634 err = &smithy.DeserializationError{ 635 Err: fmt.Errorf("failed to decode response body, %w", err), 636 Snapshot: snapshot.Bytes(), 637 } 638 return out, metadata, err 639 } 640 641 err = awsAwsjson11_deserializeOpDocumentDisableDomainAutoRenewOutput(&output, shape) 642 if err != nil { 643 var snapshot bytes.Buffer 644 io.Copy(&snapshot, ringBuffer) 645 err = &smithy.DeserializationError{ 646 Err: fmt.Errorf("failed to decode response body, %w", err), 647 Snapshot: snapshot.Bytes(), 648 } 649 return out, metadata, err 650 } 651 652 return out, metadata, err 653} 654 655func awsAwsjson11_deserializeOpErrorDisableDomainAutoRenew(response *smithyhttp.Response, metadata *middleware.Metadata) error { 656 var errorBuffer bytes.Buffer 657 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 658 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 659 } 660 errorBody := bytes.NewReader(errorBuffer.Bytes()) 661 662 errorCode := "UnknownError" 663 errorMessage := errorCode 664 665 code := response.Header.Get("X-Amzn-ErrorType") 666 if len(code) != 0 { 667 errorCode = restjson.SanitizeErrorCode(code) 668 } 669 670 var buff [1024]byte 671 ringBuffer := smithyio.NewRingBuffer(buff[:]) 672 673 body := io.TeeReader(errorBody, ringBuffer) 674 decoder := json.NewDecoder(body) 675 decoder.UseNumber() 676 code, message, err := restjson.GetErrorInfo(decoder) 677 if err != nil { 678 var snapshot bytes.Buffer 679 io.Copy(&snapshot, ringBuffer) 680 err = &smithy.DeserializationError{ 681 Err: fmt.Errorf("failed to decode response body, %w", err), 682 Snapshot: snapshot.Bytes(), 683 } 684 return err 685 } 686 687 errorBody.Seek(0, io.SeekStart) 688 if len(code) != 0 { 689 errorCode = restjson.SanitizeErrorCode(code) 690 } 691 if len(message) != 0 { 692 errorMessage = message 693 } 694 695 switch { 696 case strings.EqualFold("InvalidInput", errorCode): 697 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 698 699 case strings.EqualFold("UnsupportedTLD", errorCode): 700 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 701 702 default: 703 genericError := &smithy.GenericAPIError{ 704 Code: errorCode, 705 Message: errorMessage, 706 } 707 return genericError 708 709 } 710} 711 712type awsAwsjson11_deserializeOpDisableDomainTransferLock struct { 713} 714 715func (*awsAwsjson11_deserializeOpDisableDomainTransferLock) ID() string { 716 return "OperationDeserializer" 717} 718 719func (m *awsAwsjson11_deserializeOpDisableDomainTransferLock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 720 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 721) { 722 out, metadata, err = next.HandleDeserialize(ctx, in) 723 if err != nil { 724 return out, metadata, err 725 } 726 727 response, ok := out.RawResponse.(*smithyhttp.Response) 728 if !ok { 729 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 730 } 731 732 if response.StatusCode < 200 || response.StatusCode >= 300 { 733 return out, metadata, awsAwsjson11_deserializeOpErrorDisableDomainTransferLock(response, &metadata) 734 } 735 output := &DisableDomainTransferLockOutput{} 736 out.Result = output 737 738 var buff [1024]byte 739 ringBuffer := smithyio.NewRingBuffer(buff[:]) 740 741 body := io.TeeReader(response.Body, ringBuffer) 742 decoder := json.NewDecoder(body) 743 decoder.UseNumber() 744 var shape interface{} 745 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 746 var snapshot bytes.Buffer 747 io.Copy(&snapshot, ringBuffer) 748 err = &smithy.DeserializationError{ 749 Err: fmt.Errorf("failed to decode response body, %w", err), 750 Snapshot: snapshot.Bytes(), 751 } 752 return out, metadata, err 753 } 754 755 err = awsAwsjson11_deserializeOpDocumentDisableDomainTransferLockOutput(&output, shape) 756 if err != nil { 757 var snapshot bytes.Buffer 758 io.Copy(&snapshot, ringBuffer) 759 err = &smithy.DeserializationError{ 760 Err: fmt.Errorf("failed to decode response body, %w", err), 761 Snapshot: snapshot.Bytes(), 762 } 763 return out, metadata, err 764 } 765 766 return out, metadata, err 767} 768 769func awsAwsjson11_deserializeOpErrorDisableDomainTransferLock(response *smithyhttp.Response, metadata *middleware.Metadata) error { 770 var errorBuffer bytes.Buffer 771 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 772 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 773 } 774 errorBody := bytes.NewReader(errorBuffer.Bytes()) 775 776 errorCode := "UnknownError" 777 errorMessage := errorCode 778 779 code := response.Header.Get("X-Amzn-ErrorType") 780 if len(code) != 0 { 781 errorCode = restjson.SanitizeErrorCode(code) 782 } 783 784 var buff [1024]byte 785 ringBuffer := smithyio.NewRingBuffer(buff[:]) 786 787 body := io.TeeReader(errorBody, ringBuffer) 788 decoder := json.NewDecoder(body) 789 decoder.UseNumber() 790 code, message, err := restjson.GetErrorInfo(decoder) 791 if err != nil { 792 var snapshot bytes.Buffer 793 io.Copy(&snapshot, ringBuffer) 794 err = &smithy.DeserializationError{ 795 Err: fmt.Errorf("failed to decode response body, %w", err), 796 Snapshot: snapshot.Bytes(), 797 } 798 return err 799 } 800 801 errorBody.Seek(0, io.SeekStart) 802 if len(code) != 0 { 803 errorCode = restjson.SanitizeErrorCode(code) 804 } 805 if len(message) != 0 { 806 errorMessage = message 807 } 808 809 switch { 810 case strings.EqualFold("DuplicateRequest", errorCode): 811 return awsAwsjson11_deserializeErrorDuplicateRequest(response, errorBody) 812 813 case strings.EqualFold("InvalidInput", errorCode): 814 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 815 816 case strings.EqualFold("OperationLimitExceeded", errorCode): 817 return awsAwsjson11_deserializeErrorOperationLimitExceeded(response, errorBody) 818 819 case strings.EqualFold("TLDRulesViolation", errorCode): 820 return awsAwsjson11_deserializeErrorTLDRulesViolation(response, errorBody) 821 822 case strings.EqualFold("UnsupportedTLD", errorCode): 823 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 824 825 default: 826 genericError := &smithy.GenericAPIError{ 827 Code: errorCode, 828 Message: errorMessage, 829 } 830 return genericError 831 832 } 833} 834 835type awsAwsjson11_deserializeOpEnableDomainAutoRenew struct { 836} 837 838func (*awsAwsjson11_deserializeOpEnableDomainAutoRenew) ID() string { 839 return "OperationDeserializer" 840} 841 842func (m *awsAwsjson11_deserializeOpEnableDomainAutoRenew) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 843 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 844) { 845 out, metadata, err = next.HandleDeserialize(ctx, in) 846 if err != nil { 847 return out, metadata, err 848 } 849 850 response, ok := out.RawResponse.(*smithyhttp.Response) 851 if !ok { 852 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 853 } 854 855 if response.StatusCode < 200 || response.StatusCode >= 300 { 856 return out, metadata, awsAwsjson11_deserializeOpErrorEnableDomainAutoRenew(response, &metadata) 857 } 858 output := &EnableDomainAutoRenewOutput{} 859 out.Result = output 860 861 var buff [1024]byte 862 ringBuffer := smithyio.NewRingBuffer(buff[:]) 863 864 body := io.TeeReader(response.Body, ringBuffer) 865 decoder := json.NewDecoder(body) 866 decoder.UseNumber() 867 var shape interface{} 868 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 869 var snapshot bytes.Buffer 870 io.Copy(&snapshot, ringBuffer) 871 err = &smithy.DeserializationError{ 872 Err: fmt.Errorf("failed to decode response body, %w", err), 873 Snapshot: snapshot.Bytes(), 874 } 875 return out, metadata, err 876 } 877 878 err = awsAwsjson11_deserializeOpDocumentEnableDomainAutoRenewOutput(&output, shape) 879 if err != nil { 880 var snapshot bytes.Buffer 881 io.Copy(&snapshot, ringBuffer) 882 err = &smithy.DeserializationError{ 883 Err: fmt.Errorf("failed to decode response body, %w", err), 884 Snapshot: snapshot.Bytes(), 885 } 886 return out, metadata, err 887 } 888 889 return out, metadata, err 890} 891 892func awsAwsjson11_deserializeOpErrorEnableDomainAutoRenew(response *smithyhttp.Response, metadata *middleware.Metadata) error { 893 var errorBuffer bytes.Buffer 894 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 895 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 896 } 897 errorBody := bytes.NewReader(errorBuffer.Bytes()) 898 899 errorCode := "UnknownError" 900 errorMessage := errorCode 901 902 code := response.Header.Get("X-Amzn-ErrorType") 903 if len(code) != 0 { 904 errorCode = restjson.SanitizeErrorCode(code) 905 } 906 907 var buff [1024]byte 908 ringBuffer := smithyio.NewRingBuffer(buff[:]) 909 910 body := io.TeeReader(errorBody, ringBuffer) 911 decoder := json.NewDecoder(body) 912 decoder.UseNumber() 913 code, message, err := restjson.GetErrorInfo(decoder) 914 if err != nil { 915 var snapshot bytes.Buffer 916 io.Copy(&snapshot, ringBuffer) 917 err = &smithy.DeserializationError{ 918 Err: fmt.Errorf("failed to decode response body, %w", err), 919 Snapshot: snapshot.Bytes(), 920 } 921 return err 922 } 923 924 errorBody.Seek(0, io.SeekStart) 925 if len(code) != 0 { 926 errorCode = restjson.SanitizeErrorCode(code) 927 } 928 if len(message) != 0 { 929 errorMessage = message 930 } 931 932 switch { 933 case strings.EqualFold("InvalidInput", errorCode): 934 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 935 936 case strings.EqualFold("TLDRulesViolation", errorCode): 937 return awsAwsjson11_deserializeErrorTLDRulesViolation(response, errorBody) 938 939 case strings.EqualFold("UnsupportedTLD", errorCode): 940 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 941 942 default: 943 genericError := &smithy.GenericAPIError{ 944 Code: errorCode, 945 Message: errorMessage, 946 } 947 return genericError 948 949 } 950} 951 952type awsAwsjson11_deserializeOpEnableDomainTransferLock struct { 953} 954 955func (*awsAwsjson11_deserializeOpEnableDomainTransferLock) ID() string { 956 return "OperationDeserializer" 957} 958 959func (m *awsAwsjson11_deserializeOpEnableDomainTransferLock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 960 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 961) { 962 out, metadata, err = next.HandleDeserialize(ctx, in) 963 if err != nil { 964 return out, metadata, err 965 } 966 967 response, ok := out.RawResponse.(*smithyhttp.Response) 968 if !ok { 969 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 970 } 971 972 if response.StatusCode < 200 || response.StatusCode >= 300 { 973 return out, metadata, awsAwsjson11_deserializeOpErrorEnableDomainTransferLock(response, &metadata) 974 } 975 output := &EnableDomainTransferLockOutput{} 976 out.Result = output 977 978 var buff [1024]byte 979 ringBuffer := smithyio.NewRingBuffer(buff[:]) 980 981 body := io.TeeReader(response.Body, ringBuffer) 982 decoder := json.NewDecoder(body) 983 decoder.UseNumber() 984 var shape interface{} 985 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 986 var snapshot bytes.Buffer 987 io.Copy(&snapshot, ringBuffer) 988 err = &smithy.DeserializationError{ 989 Err: fmt.Errorf("failed to decode response body, %w", err), 990 Snapshot: snapshot.Bytes(), 991 } 992 return out, metadata, err 993 } 994 995 err = awsAwsjson11_deserializeOpDocumentEnableDomainTransferLockOutput(&output, shape) 996 if err != nil { 997 var snapshot bytes.Buffer 998 io.Copy(&snapshot, ringBuffer) 999 err = &smithy.DeserializationError{ 1000 Err: fmt.Errorf("failed to decode response body, %w", err), 1001 Snapshot: snapshot.Bytes(), 1002 } 1003 return out, metadata, err 1004 } 1005 1006 return out, metadata, err 1007} 1008 1009func awsAwsjson11_deserializeOpErrorEnableDomainTransferLock(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1010 var errorBuffer bytes.Buffer 1011 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1012 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1013 } 1014 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1015 1016 errorCode := "UnknownError" 1017 errorMessage := errorCode 1018 1019 code := response.Header.Get("X-Amzn-ErrorType") 1020 if len(code) != 0 { 1021 errorCode = restjson.SanitizeErrorCode(code) 1022 } 1023 1024 var buff [1024]byte 1025 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1026 1027 body := io.TeeReader(errorBody, ringBuffer) 1028 decoder := json.NewDecoder(body) 1029 decoder.UseNumber() 1030 code, message, err := restjson.GetErrorInfo(decoder) 1031 if err != nil { 1032 var snapshot bytes.Buffer 1033 io.Copy(&snapshot, ringBuffer) 1034 err = &smithy.DeserializationError{ 1035 Err: fmt.Errorf("failed to decode response body, %w", err), 1036 Snapshot: snapshot.Bytes(), 1037 } 1038 return err 1039 } 1040 1041 errorBody.Seek(0, io.SeekStart) 1042 if len(code) != 0 { 1043 errorCode = restjson.SanitizeErrorCode(code) 1044 } 1045 if len(message) != 0 { 1046 errorMessage = message 1047 } 1048 1049 switch { 1050 case strings.EqualFold("DuplicateRequest", errorCode): 1051 return awsAwsjson11_deserializeErrorDuplicateRequest(response, errorBody) 1052 1053 case strings.EqualFold("InvalidInput", errorCode): 1054 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 1055 1056 case strings.EqualFold("OperationLimitExceeded", errorCode): 1057 return awsAwsjson11_deserializeErrorOperationLimitExceeded(response, errorBody) 1058 1059 case strings.EqualFold("TLDRulesViolation", errorCode): 1060 return awsAwsjson11_deserializeErrorTLDRulesViolation(response, errorBody) 1061 1062 case strings.EqualFold("UnsupportedTLD", errorCode): 1063 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 1064 1065 default: 1066 genericError := &smithy.GenericAPIError{ 1067 Code: errorCode, 1068 Message: errorMessage, 1069 } 1070 return genericError 1071 1072 } 1073} 1074 1075type awsAwsjson11_deserializeOpGetContactReachabilityStatus struct { 1076} 1077 1078func (*awsAwsjson11_deserializeOpGetContactReachabilityStatus) ID() string { 1079 return "OperationDeserializer" 1080} 1081 1082func (m *awsAwsjson11_deserializeOpGetContactReachabilityStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1083 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1084) { 1085 out, metadata, err = next.HandleDeserialize(ctx, in) 1086 if err != nil { 1087 return out, metadata, err 1088 } 1089 1090 response, ok := out.RawResponse.(*smithyhttp.Response) 1091 if !ok { 1092 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1093 } 1094 1095 if response.StatusCode < 200 || response.StatusCode >= 300 { 1096 return out, metadata, awsAwsjson11_deserializeOpErrorGetContactReachabilityStatus(response, &metadata) 1097 } 1098 output := &GetContactReachabilityStatusOutput{} 1099 out.Result = output 1100 1101 var buff [1024]byte 1102 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1103 1104 body := io.TeeReader(response.Body, ringBuffer) 1105 decoder := json.NewDecoder(body) 1106 decoder.UseNumber() 1107 var shape interface{} 1108 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1109 var snapshot bytes.Buffer 1110 io.Copy(&snapshot, ringBuffer) 1111 err = &smithy.DeserializationError{ 1112 Err: fmt.Errorf("failed to decode response body, %w", err), 1113 Snapshot: snapshot.Bytes(), 1114 } 1115 return out, metadata, err 1116 } 1117 1118 err = awsAwsjson11_deserializeOpDocumentGetContactReachabilityStatusOutput(&output, shape) 1119 if err != nil { 1120 var snapshot bytes.Buffer 1121 io.Copy(&snapshot, ringBuffer) 1122 err = &smithy.DeserializationError{ 1123 Err: fmt.Errorf("failed to decode response body, %w", err), 1124 Snapshot: snapshot.Bytes(), 1125 } 1126 return out, metadata, err 1127 } 1128 1129 return out, metadata, err 1130} 1131 1132func awsAwsjson11_deserializeOpErrorGetContactReachabilityStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1133 var errorBuffer bytes.Buffer 1134 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1135 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1136 } 1137 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1138 1139 errorCode := "UnknownError" 1140 errorMessage := errorCode 1141 1142 code := response.Header.Get("X-Amzn-ErrorType") 1143 if len(code) != 0 { 1144 errorCode = restjson.SanitizeErrorCode(code) 1145 } 1146 1147 var buff [1024]byte 1148 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1149 1150 body := io.TeeReader(errorBody, ringBuffer) 1151 decoder := json.NewDecoder(body) 1152 decoder.UseNumber() 1153 code, message, err := restjson.GetErrorInfo(decoder) 1154 if err != nil { 1155 var snapshot bytes.Buffer 1156 io.Copy(&snapshot, ringBuffer) 1157 err = &smithy.DeserializationError{ 1158 Err: fmt.Errorf("failed to decode response body, %w", err), 1159 Snapshot: snapshot.Bytes(), 1160 } 1161 return err 1162 } 1163 1164 errorBody.Seek(0, io.SeekStart) 1165 if len(code) != 0 { 1166 errorCode = restjson.SanitizeErrorCode(code) 1167 } 1168 if len(message) != 0 { 1169 errorMessage = message 1170 } 1171 1172 switch { 1173 case strings.EqualFold("InvalidInput", errorCode): 1174 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 1175 1176 case strings.EqualFold("OperationLimitExceeded", errorCode): 1177 return awsAwsjson11_deserializeErrorOperationLimitExceeded(response, errorBody) 1178 1179 case strings.EqualFold("UnsupportedTLD", errorCode): 1180 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 1181 1182 default: 1183 genericError := &smithy.GenericAPIError{ 1184 Code: errorCode, 1185 Message: errorMessage, 1186 } 1187 return genericError 1188 1189 } 1190} 1191 1192type awsAwsjson11_deserializeOpGetDomainDetail struct { 1193} 1194 1195func (*awsAwsjson11_deserializeOpGetDomainDetail) ID() string { 1196 return "OperationDeserializer" 1197} 1198 1199func (m *awsAwsjson11_deserializeOpGetDomainDetail) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1200 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1201) { 1202 out, metadata, err = next.HandleDeserialize(ctx, in) 1203 if err != nil { 1204 return out, metadata, err 1205 } 1206 1207 response, ok := out.RawResponse.(*smithyhttp.Response) 1208 if !ok { 1209 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1210 } 1211 1212 if response.StatusCode < 200 || response.StatusCode >= 300 { 1213 return out, metadata, awsAwsjson11_deserializeOpErrorGetDomainDetail(response, &metadata) 1214 } 1215 output := &GetDomainDetailOutput{} 1216 out.Result = output 1217 1218 var buff [1024]byte 1219 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1220 1221 body := io.TeeReader(response.Body, ringBuffer) 1222 decoder := json.NewDecoder(body) 1223 decoder.UseNumber() 1224 var shape interface{} 1225 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1226 var snapshot bytes.Buffer 1227 io.Copy(&snapshot, ringBuffer) 1228 err = &smithy.DeserializationError{ 1229 Err: fmt.Errorf("failed to decode response body, %w", err), 1230 Snapshot: snapshot.Bytes(), 1231 } 1232 return out, metadata, err 1233 } 1234 1235 err = awsAwsjson11_deserializeOpDocumentGetDomainDetailOutput(&output, shape) 1236 if err != nil { 1237 var snapshot bytes.Buffer 1238 io.Copy(&snapshot, ringBuffer) 1239 err = &smithy.DeserializationError{ 1240 Err: fmt.Errorf("failed to decode response body, %w", err), 1241 Snapshot: snapshot.Bytes(), 1242 } 1243 return out, metadata, err 1244 } 1245 1246 return out, metadata, err 1247} 1248 1249func awsAwsjson11_deserializeOpErrorGetDomainDetail(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1250 var errorBuffer bytes.Buffer 1251 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1252 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1253 } 1254 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1255 1256 errorCode := "UnknownError" 1257 errorMessage := errorCode 1258 1259 code := response.Header.Get("X-Amzn-ErrorType") 1260 if len(code) != 0 { 1261 errorCode = restjson.SanitizeErrorCode(code) 1262 } 1263 1264 var buff [1024]byte 1265 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1266 1267 body := io.TeeReader(errorBody, ringBuffer) 1268 decoder := json.NewDecoder(body) 1269 decoder.UseNumber() 1270 code, message, err := restjson.GetErrorInfo(decoder) 1271 if err != nil { 1272 var snapshot bytes.Buffer 1273 io.Copy(&snapshot, ringBuffer) 1274 err = &smithy.DeserializationError{ 1275 Err: fmt.Errorf("failed to decode response body, %w", err), 1276 Snapshot: snapshot.Bytes(), 1277 } 1278 return err 1279 } 1280 1281 errorBody.Seek(0, io.SeekStart) 1282 if len(code) != 0 { 1283 errorCode = restjson.SanitizeErrorCode(code) 1284 } 1285 if len(message) != 0 { 1286 errorMessage = message 1287 } 1288 1289 switch { 1290 case strings.EqualFold("InvalidInput", errorCode): 1291 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 1292 1293 case strings.EqualFold("UnsupportedTLD", errorCode): 1294 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 1295 1296 default: 1297 genericError := &smithy.GenericAPIError{ 1298 Code: errorCode, 1299 Message: errorMessage, 1300 } 1301 return genericError 1302 1303 } 1304} 1305 1306type awsAwsjson11_deserializeOpGetDomainSuggestions struct { 1307} 1308 1309func (*awsAwsjson11_deserializeOpGetDomainSuggestions) ID() string { 1310 return "OperationDeserializer" 1311} 1312 1313func (m *awsAwsjson11_deserializeOpGetDomainSuggestions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1314 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1315) { 1316 out, metadata, err = next.HandleDeserialize(ctx, in) 1317 if err != nil { 1318 return out, metadata, err 1319 } 1320 1321 response, ok := out.RawResponse.(*smithyhttp.Response) 1322 if !ok { 1323 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1324 } 1325 1326 if response.StatusCode < 200 || response.StatusCode >= 300 { 1327 return out, metadata, awsAwsjson11_deserializeOpErrorGetDomainSuggestions(response, &metadata) 1328 } 1329 output := &GetDomainSuggestionsOutput{} 1330 out.Result = output 1331 1332 var buff [1024]byte 1333 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1334 1335 body := io.TeeReader(response.Body, ringBuffer) 1336 decoder := json.NewDecoder(body) 1337 decoder.UseNumber() 1338 var shape interface{} 1339 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1340 var snapshot bytes.Buffer 1341 io.Copy(&snapshot, ringBuffer) 1342 err = &smithy.DeserializationError{ 1343 Err: fmt.Errorf("failed to decode response body, %w", err), 1344 Snapshot: snapshot.Bytes(), 1345 } 1346 return out, metadata, err 1347 } 1348 1349 err = awsAwsjson11_deserializeOpDocumentGetDomainSuggestionsOutput(&output, shape) 1350 if err != nil { 1351 var snapshot bytes.Buffer 1352 io.Copy(&snapshot, ringBuffer) 1353 err = &smithy.DeserializationError{ 1354 Err: fmt.Errorf("failed to decode response body, %w", err), 1355 Snapshot: snapshot.Bytes(), 1356 } 1357 return out, metadata, err 1358 } 1359 1360 return out, metadata, err 1361} 1362 1363func awsAwsjson11_deserializeOpErrorGetDomainSuggestions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1364 var errorBuffer bytes.Buffer 1365 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1366 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1367 } 1368 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1369 1370 errorCode := "UnknownError" 1371 errorMessage := errorCode 1372 1373 code := response.Header.Get("X-Amzn-ErrorType") 1374 if len(code) != 0 { 1375 errorCode = restjson.SanitizeErrorCode(code) 1376 } 1377 1378 var buff [1024]byte 1379 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1380 1381 body := io.TeeReader(errorBody, ringBuffer) 1382 decoder := json.NewDecoder(body) 1383 decoder.UseNumber() 1384 code, message, err := restjson.GetErrorInfo(decoder) 1385 if err != nil { 1386 var snapshot bytes.Buffer 1387 io.Copy(&snapshot, ringBuffer) 1388 err = &smithy.DeserializationError{ 1389 Err: fmt.Errorf("failed to decode response body, %w", err), 1390 Snapshot: snapshot.Bytes(), 1391 } 1392 return err 1393 } 1394 1395 errorBody.Seek(0, io.SeekStart) 1396 if len(code) != 0 { 1397 errorCode = restjson.SanitizeErrorCode(code) 1398 } 1399 if len(message) != 0 { 1400 errorMessage = message 1401 } 1402 1403 switch { 1404 case strings.EqualFold("InvalidInput", errorCode): 1405 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 1406 1407 case strings.EqualFold("UnsupportedTLD", errorCode): 1408 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 1409 1410 default: 1411 genericError := &smithy.GenericAPIError{ 1412 Code: errorCode, 1413 Message: errorMessage, 1414 } 1415 return genericError 1416 1417 } 1418} 1419 1420type awsAwsjson11_deserializeOpGetOperationDetail struct { 1421} 1422 1423func (*awsAwsjson11_deserializeOpGetOperationDetail) ID() string { 1424 return "OperationDeserializer" 1425} 1426 1427func (m *awsAwsjson11_deserializeOpGetOperationDetail) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1428 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1429) { 1430 out, metadata, err = next.HandleDeserialize(ctx, in) 1431 if err != nil { 1432 return out, metadata, err 1433 } 1434 1435 response, ok := out.RawResponse.(*smithyhttp.Response) 1436 if !ok { 1437 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1438 } 1439 1440 if response.StatusCode < 200 || response.StatusCode >= 300 { 1441 return out, metadata, awsAwsjson11_deserializeOpErrorGetOperationDetail(response, &metadata) 1442 } 1443 output := &GetOperationDetailOutput{} 1444 out.Result = output 1445 1446 var buff [1024]byte 1447 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1448 1449 body := io.TeeReader(response.Body, ringBuffer) 1450 decoder := json.NewDecoder(body) 1451 decoder.UseNumber() 1452 var shape interface{} 1453 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1454 var snapshot bytes.Buffer 1455 io.Copy(&snapshot, ringBuffer) 1456 err = &smithy.DeserializationError{ 1457 Err: fmt.Errorf("failed to decode response body, %w", err), 1458 Snapshot: snapshot.Bytes(), 1459 } 1460 return out, metadata, err 1461 } 1462 1463 err = awsAwsjson11_deserializeOpDocumentGetOperationDetailOutput(&output, shape) 1464 if err != nil { 1465 var snapshot bytes.Buffer 1466 io.Copy(&snapshot, ringBuffer) 1467 err = &smithy.DeserializationError{ 1468 Err: fmt.Errorf("failed to decode response body, %w", err), 1469 Snapshot: snapshot.Bytes(), 1470 } 1471 return out, metadata, err 1472 } 1473 1474 return out, metadata, err 1475} 1476 1477func awsAwsjson11_deserializeOpErrorGetOperationDetail(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1478 var errorBuffer bytes.Buffer 1479 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1480 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1481 } 1482 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1483 1484 errorCode := "UnknownError" 1485 errorMessage := errorCode 1486 1487 code := response.Header.Get("X-Amzn-ErrorType") 1488 if len(code) != 0 { 1489 errorCode = restjson.SanitizeErrorCode(code) 1490 } 1491 1492 var buff [1024]byte 1493 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1494 1495 body := io.TeeReader(errorBody, ringBuffer) 1496 decoder := json.NewDecoder(body) 1497 decoder.UseNumber() 1498 code, message, err := restjson.GetErrorInfo(decoder) 1499 if err != nil { 1500 var snapshot bytes.Buffer 1501 io.Copy(&snapshot, ringBuffer) 1502 err = &smithy.DeserializationError{ 1503 Err: fmt.Errorf("failed to decode response body, %w", err), 1504 Snapshot: snapshot.Bytes(), 1505 } 1506 return err 1507 } 1508 1509 errorBody.Seek(0, io.SeekStart) 1510 if len(code) != 0 { 1511 errorCode = restjson.SanitizeErrorCode(code) 1512 } 1513 if len(message) != 0 { 1514 errorMessage = message 1515 } 1516 1517 switch { 1518 case strings.EqualFold("InvalidInput", errorCode): 1519 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 1520 1521 default: 1522 genericError := &smithy.GenericAPIError{ 1523 Code: errorCode, 1524 Message: errorMessage, 1525 } 1526 return genericError 1527 1528 } 1529} 1530 1531type awsAwsjson11_deserializeOpListDomains struct { 1532} 1533 1534func (*awsAwsjson11_deserializeOpListDomains) ID() string { 1535 return "OperationDeserializer" 1536} 1537 1538func (m *awsAwsjson11_deserializeOpListDomains) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1539 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1540) { 1541 out, metadata, err = next.HandleDeserialize(ctx, in) 1542 if err != nil { 1543 return out, metadata, err 1544 } 1545 1546 response, ok := out.RawResponse.(*smithyhttp.Response) 1547 if !ok { 1548 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1549 } 1550 1551 if response.StatusCode < 200 || response.StatusCode >= 300 { 1552 return out, metadata, awsAwsjson11_deserializeOpErrorListDomains(response, &metadata) 1553 } 1554 output := &ListDomainsOutput{} 1555 out.Result = output 1556 1557 var buff [1024]byte 1558 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1559 1560 body := io.TeeReader(response.Body, ringBuffer) 1561 decoder := json.NewDecoder(body) 1562 decoder.UseNumber() 1563 var shape interface{} 1564 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1565 var snapshot bytes.Buffer 1566 io.Copy(&snapshot, ringBuffer) 1567 err = &smithy.DeserializationError{ 1568 Err: fmt.Errorf("failed to decode response body, %w", err), 1569 Snapshot: snapshot.Bytes(), 1570 } 1571 return out, metadata, err 1572 } 1573 1574 err = awsAwsjson11_deserializeOpDocumentListDomainsOutput(&output, shape) 1575 if err != nil { 1576 var snapshot bytes.Buffer 1577 io.Copy(&snapshot, ringBuffer) 1578 err = &smithy.DeserializationError{ 1579 Err: fmt.Errorf("failed to decode response body, %w", err), 1580 Snapshot: snapshot.Bytes(), 1581 } 1582 return out, metadata, err 1583 } 1584 1585 return out, metadata, err 1586} 1587 1588func awsAwsjson11_deserializeOpErrorListDomains(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1589 var errorBuffer bytes.Buffer 1590 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1591 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1592 } 1593 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1594 1595 errorCode := "UnknownError" 1596 errorMessage := errorCode 1597 1598 code := response.Header.Get("X-Amzn-ErrorType") 1599 if len(code) != 0 { 1600 errorCode = restjson.SanitizeErrorCode(code) 1601 } 1602 1603 var buff [1024]byte 1604 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1605 1606 body := io.TeeReader(errorBody, ringBuffer) 1607 decoder := json.NewDecoder(body) 1608 decoder.UseNumber() 1609 code, message, err := restjson.GetErrorInfo(decoder) 1610 if err != nil { 1611 var snapshot bytes.Buffer 1612 io.Copy(&snapshot, ringBuffer) 1613 err = &smithy.DeserializationError{ 1614 Err: fmt.Errorf("failed to decode response body, %w", err), 1615 Snapshot: snapshot.Bytes(), 1616 } 1617 return err 1618 } 1619 1620 errorBody.Seek(0, io.SeekStart) 1621 if len(code) != 0 { 1622 errorCode = restjson.SanitizeErrorCode(code) 1623 } 1624 if len(message) != 0 { 1625 errorMessage = message 1626 } 1627 1628 switch { 1629 case strings.EqualFold("InvalidInput", errorCode): 1630 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 1631 1632 default: 1633 genericError := &smithy.GenericAPIError{ 1634 Code: errorCode, 1635 Message: errorMessage, 1636 } 1637 return genericError 1638 1639 } 1640} 1641 1642type awsAwsjson11_deserializeOpListOperations struct { 1643} 1644 1645func (*awsAwsjson11_deserializeOpListOperations) ID() string { 1646 return "OperationDeserializer" 1647} 1648 1649func (m *awsAwsjson11_deserializeOpListOperations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1650 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1651) { 1652 out, metadata, err = next.HandleDeserialize(ctx, in) 1653 if err != nil { 1654 return out, metadata, err 1655 } 1656 1657 response, ok := out.RawResponse.(*smithyhttp.Response) 1658 if !ok { 1659 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1660 } 1661 1662 if response.StatusCode < 200 || response.StatusCode >= 300 { 1663 return out, metadata, awsAwsjson11_deserializeOpErrorListOperations(response, &metadata) 1664 } 1665 output := &ListOperationsOutput{} 1666 out.Result = output 1667 1668 var buff [1024]byte 1669 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1670 1671 body := io.TeeReader(response.Body, ringBuffer) 1672 decoder := json.NewDecoder(body) 1673 decoder.UseNumber() 1674 var shape interface{} 1675 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1676 var snapshot bytes.Buffer 1677 io.Copy(&snapshot, ringBuffer) 1678 err = &smithy.DeserializationError{ 1679 Err: fmt.Errorf("failed to decode response body, %w", err), 1680 Snapshot: snapshot.Bytes(), 1681 } 1682 return out, metadata, err 1683 } 1684 1685 err = awsAwsjson11_deserializeOpDocumentListOperationsOutput(&output, shape) 1686 if err != nil { 1687 var snapshot bytes.Buffer 1688 io.Copy(&snapshot, ringBuffer) 1689 err = &smithy.DeserializationError{ 1690 Err: fmt.Errorf("failed to decode response body, %w", err), 1691 Snapshot: snapshot.Bytes(), 1692 } 1693 return out, metadata, err 1694 } 1695 1696 return out, metadata, err 1697} 1698 1699func awsAwsjson11_deserializeOpErrorListOperations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1700 var errorBuffer bytes.Buffer 1701 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1702 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1703 } 1704 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1705 1706 errorCode := "UnknownError" 1707 errorMessage := errorCode 1708 1709 code := response.Header.Get("X-Amzn-ErrorType") 1710 if len(code) != 0 { 1711 errorCode = restjson.SanitizeErrorCode(code) 1712 } 1713 1714 var buff [1024]byte 1715 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1716 1717 body := io.TeeReader(errorBody, ringBuffer) 1718 decoder := json.NewDecoder(body) 1719 decoder.UseNumber() 1720 code, message, err := restjson.GetErrorInfo(decoder) 1721 if err != nil { 1722 var snapshot bytes.Buffer 1723 io.Copy(&snapshot, ringBuffer) 1724 err = &smithy.DeserializationError{ 1725 Err: fmt.Errorf("failed to decode response body, %w", err), 1726 Snapshot: snapshot.Bytes(), 1727 } 1728 return err 1729 } 1730 1731 errorBody.Seek(0, io.SeekStart) 1732 if len(code) != 0 { 1733 errorCode = restjson.SanitizeErrorCode(code) 1734 } 1735 if len(message) != 0 { 1736 errorMessage = message 1737 } 1738 1739 switch { 1740 case strings.EqualFold("InvalidInput", errorCode): 1741 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 1742 1743 default: 1744 genericError := &smithy.GenericAPIError{ 1745 Code: errorCode, 1746 Message: errorMessage, 1747 } 1748 return genericError 1749 1750 } 1751} 1752 1753type awsAwsjson11_deserializeOpListTagsForDomain struct { 1754} 1755 1756func (*awsAwsjson11_deserializeOpListTagsForDomain) ID() string { 1757 return "OperationDeserializer" 1758} 1759 1760func (m *awsAwsjson11_deserializeOpListTagsForDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1761 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1762) { 1763 out, metadata, err = next.HandleDeserialize(ctx, in) 1764 if err != nil { 1765 return out, metadata, err 1766 } 1767 1768 response, ok := out.RawResponse.(*smithyhttp.Response) 1769 if !ok { 1770 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1771 } 1772 1773 if response.StatusCode < 200 || response.StatusCode >= 300 { 1774 return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForDomain(response, &metadata) 1775 } 1776 output := &ListTagsForDomainOutput{} 1777 out.Result = output 1778 1779 var buff [1024]byte 1780 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1781 1782 body := io.TeeReader(response.Body, ringBuffer) 1783 decoder := json.NewDecoder(body) 1784 decoder.UseNumber() 1785 var shape interface{} 1786 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1787 var snapshot bytes.Buffer 1788 io.Copy(&snapshot, ringBuffer) 1789 err = &smithy.DeserializationError{ 1790 Err: fmt.Errorf("failed to decode response body, %w", err), 1791 Snapshot: snapshot.Bytes(), 1792 } 1793 return out, metadata, err 1794 } 1795 1796 err = awsAwsjson11_deserializeOpDocumentListTagsForDomainOutput(&output, shape) 1797 if err != nil { 1798 var snapshot bytes.Buffer 1799 io.Copy(&snapshot, ringBuffer) 1800 err = &smithy.DeserializationError{ 1801 Err: fmt.Errorf("failed to decode response body, %w", err), 1802 Snapshot: snapshot.Bytes(), 1803 } 1804 return out, metadata, err 1805 } 1806 1807 return out, metadata, err 1808} 1809 1810func awsAwsjson11_deserializeOpErrorListTagsForDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1811 var errorBuffer bytes.Buffer 1812 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1813 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1814 } 1815 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1816 1817 errorCode := "UnknownError" 1818 errorMessage := errorCode 1819 1820 code := response.Header.Get("X-Amzn-ErrorType") 1821 if len(code) != 0 { 1822 errorCode = restjson.SanitizeErrorCode(code) 1823 } 1824 1825 var buff [1024]byte 1826 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1827 1828 body := io.TeeReader(errorBody, ringBuffer) 1829 decoder := json.NewDecoder(body) 1830 decoder.UseNumber() 1831 code, message, err := restjson.GetErrorInfo(decoder) 1832 if err != nil { 1833 var snapshot bytes.Buffer 1834 io.Copy(&snapshot, ringBuffer) 1835 err = &smithy.DeserializationError{ 1836 Err: fmt.Errorf("failed to decode response body, %w", err), 1837 Snapshot: snapshot.Bytes(), 1838 } 1839 return err 1840 } 1841 1842 errorBody.Seek(0, io.SeekStart) 1843 if len(code) != 0 { 1844 errorCode = restjson.SanitizeErrorCode(code) 1845 } 1846 if len(message) != 0 { 1847 errorMessage = message 1848 } 1849 1850 switch { 1851 case strings.EqualFold("InvalidInput", errorCode): 1852 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 1853 1854 case strings.EqualFold("OperationLimitExceeded", errorCode): 1855 return awsAwsjson11_deserializeErrorOperationLimitExceeded(response, errorBody) 1856 1857 case strings.EqualFold("UnsupportedTLD", errorCode): 1858 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 1859 1860 default: 1861 genericError := &smithy.GenericAPIError{ 1862 Code: errorCode, 1863 Message: errorMessage, 1864 } 1865 return genericError 1866 1867 } 1868} 1869 1870type awsAwsjson11_deserializeOpRegisterDomain struct { 1871} 1872 1873func (*awsAwsjson11_deserializeOpRegisterDomain) ID() string { 1874 return "OperationDeserializer" 1875} 1876 1877func (m *awsAwsjson11_deserializeOpRegisterDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1878 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1879) { 1880 out, metadata, err = next.HandleDeserialize(ctx, in) 1881 if err != nil { 1882 return out, metadata, err 1883 } 1884 1885 response, ok := out.RawResponse.(*smithyhttp.Response) 1886 if !ok { 1887 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1888 } 1889 1890 if response.StatusCode < 200 || response.StatusCode >= 300 { 1891 return out, metadata, awsAwsjson11_deserializeOpErrorRegisterDomain(response, &metadata) 1892 } 1893 output := &RegisterDomainOutput{} 1894 out.Result = output 1895 1896 var buff [1024]byte 1897 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1898 1899 body := io.TeeReader(response.Body, ringBuffer) 1900 decoder := json.NewDecoder(body) 1901 decoder.UseNumber() 1902 var shape interface{} 1903 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1904 var snapshot bytes.Buffer 1905 io.Copy(&snapshot, ringBuffer) 1906 err = &smithy.DeserializationError{ 1907 Err: fmt.Errorf("failed to decode response body, %w", err), 1908 Snapshot: snapshot.Bytes(), 1909 } 1910 return out, metadata, err 1911 } 1912 1913 err = awsAwsjson11_deserializeOpDocumentRegisterDomainOutput(&output, shape) 1914 if err != nil { 1915 var snapshot bytes.Buffer 1916 io.Copy(&snapshot, ringBuffer) 1917 err = &smithy.DeserializationError{ 1918 Err: fmt.Errorf("failed to decode response body, %w", err), 1919 Snapshot: snapshot.Bytes(), 1920 } 1921 return out, metadata, err 1922 } 1923 1924 return out, metadata, err 1925} 1926 1927func awsAwsjson11_deserializeOpErrorRegisterDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1928 var errorBuffer bytes.Buffer 1929 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1930 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1931 } 1932 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1933 1934 errorCode := "UnknownError" 1935 errorMessage := errorCode 1936 1937 code := response.Header.Get("X-Amzn-ErrorType") 1938 if len(code) != 0 { 1939 errorCode = restjson.SanitizeErrorCode(code) 1940 } 1941 1942 var buff [1024]byte 1943 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1944 1945 body := io.TeeReader(errorBody, ringBuffer) 1946 decoder := json.NewDecoder(body) 1947 decoder.UseNumber() 1948 code, message, err := restjson.GetErrorInfo(decoder) 1949 if err != nil { 1950 var snapshot bytes.Buffer 1951 io.Copy(&snapshot, ringBuffer) 1952 err = &smithy.DeserializationError{ 1953 Err: fmt.Errorf("failed to decode response body, %w", err), 1954 Snapshot: snapshot.Bytes(), 1955 } 1956 return err 1957 } 1958 1959 errorBody.Seek(0, io.SeekStart) 1960 if len(code) != 0 { 1961 errorCode = restjson.SanitizeErrorCode(code) 1962 } 1963 if len(message) != 0 { 1964 errorMessage = message 1965 } 1966 1967 switch { 1968 case strings.EqualFold("DomainLimitExceeded", errorCode): 1969 return awsAwsjson11_deserializeErrorDomainLimitExceeded(response, errorBody) 1970 1971 case strings.EqualFold("DuplicateRequest", errorCode): 1972 return awsAwsjson11_deserializeErrorDuplicateRequest(response, errorBody) 1973 1974 case strings.EqualFold("InvalidInput", errorCode): 1975 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 1976 1977 case strings.EqualFold("OperationLimitExceeded", errorCode): 1978 return awsAwsjson11_deserializeErrorOperationLimitExceeded(response, errorBody) 1979 1980 case strings.EqualFold("TLDRulesViolation", errorCode): 1981 return awsAwsjson11_deserializeErrorTLDRulesViolation(response, errorBody) 1982 1983 case strings.EqualFold("UnsupportedTLD", errorCode): 1984 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 1985 1986 default: 1987 genericError := &smithy.GenericAPIError{ 1988 Code: errorCode, 1989 Message: errorMessage, 1990 } 1991 return genericError 1992 1993 } 1994} 1995 1996type awsAwsjson11_deserializeOpRejectDomainTransferFromAnotherAwsAccount struct { 1997} 1998 1999func (*awsAwsjson11_deserializeOpRejectDomainTransferFromAnotherAwsAccount) ID() string { 2000 return "OperationDeserializer" 2001} 2002 2003func (m *awsAwsjson11_deserializeOpRejectDomainTransferFromAnotherAwsAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2004 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2005) { 2006 out, metadata, err = next.HandleDeserialize(ctx, in) 2007 if err != nil { 2008 return out, metadata, err 2009 } 2010 2011 response, ok := out.RawResponse.(*smithyhttp.Response) 2012 if !ok { 2013 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2014 } 2015 2016 if response.StatusCode < 200 || response.StatusCode >= 300 { 2017 return out, metadata, awsAwsjson11_deserializeOpErrorRejectDomainTransferFromAnotherAwsAccount(response, &metadata) 2018 } 2019 output := &RejectDomainTransferFromAnotherAwsAccountOutput{} 2020 out.Result = output 2021 2022 var buff [1024]byte 2023 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2024 2025 body := io.TeeReader(response.Body, ringBuffer) 2026 decoder := json.NewDecoder(body) 2027 decoder.UseNumber() 2028 var shape interface{} 2029 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2030 var snapshot bytes.Buffer 2031 io.Copy(&snapshot, ringBuffer) 2032 err = &smithy.DeserializationError{ 2033 Err: fmt.Errorf("failed to decode response body, %w", err), 2034 Snapshot: snapshot.Bytes(), 2035 } 2036 return out, metadata, err 2037 } 2038 2039 err = awsAwsjson11_deserializeOpDocumentRejectDomainTransferFromAnotherAwsAccountOutput(&output, shape) 2040 if err != nil { 2041 var snapshot bytes.Buffer 2042 io.Copy(&snapshot, ringBuffer) 2043 err = &smithy.DeserializationError{ 2044 Err: fmt.Errorf("failed to decode response body, %w", err), 2045 Snapshot: snapshot.Bytes(), 2046 } 2047 return out, metadata, err 2048 } 2049 2050 return out, metadata, err 2051} 2052 2053func awsAwsjson11_deserializeOpErrorRejectDomainTransferFromAnotherAwsAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2054 var errorBuffer bytes.Buffer 2055 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2056 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2057 } 2058 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2059 2060 errorCode := "UnknownError" 2061 errorMessage := errorCode 2062 2063 code := response.Header.Get("X-Amzn-ErrorType") 2064 if len(code) != 0 { 2065 errorCode = restjson.SanitizeErrorCode(code) 2066 } 2067 2068 var buff [1024]byte 2069 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2070 2071 body := io.TeeReader(errorBody, ringBuffer) 2072 decoder := json.NewDecoder(body) 2073 decoder.UseNumber() 2074 code, message, err := restjson.GetErrorInfo(decoder) 2075 if err != nil { 2076 var snapshot bytes.Buffer 2077 io.Copy(&snapshot, ringBuffer) 2078 err = &smithy.DeserializationError{ 2079 Err: fmt.Errorf("failed to decode response body, %w", err), 2080 Snapshot: snapshot.Bytes(), 2081 } 2082 return err 2083 } 2084 2085 errorBody.Seek(0, io.SeekStart) 2086 if len(code) != 0 { 2087 errorCode = restjson.SanitizeErrorCode(code) 2088 } 2089 if len(message) != 0 { 2090 errorMessage = message 2091 } 2092 2093 switch { 2094 case strings.EqualFold("InvalidInput", errorCode): 2095 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 2096 2097 case strings.EqualFold("OperationLimitExceeded", errorCode): 2098 return awsAwsjson11_deserializeErrorOperationLimitExceeded(response, errorBody) 2099 2100 default: 2101 genericError := &smithy.GenericAPIError{ 2102 Code: errorCode, 2103 Message: errorMessage, 2104 } 2105 return genericError 2106 2107 } 2108} 2109 2110type awsAwsjson11_deserializeOpRenewDomain struct { 2111} 2112 2113func (*awsAwsjson11_deserializeOpRenewDomain) ID() string { 2114 return "OperationDeserializer" 2115} 2116 2117func (m *awsAwsjson11_deserializeOpRenewDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2118 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2119) { 2120 out, metadata, err = next.HandleDeserialize(ctx, in) 2121 if err != nil { 2122 return out, metadata, err 2123 } 2124 2125 response, ok := out.RawResponse.(*smithyhttp.Response) 2126 if !ok { 2127 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2128 } 2129 2130 if response.StatusCode < 200 || response.StatusCode >= 300 { 2131 return out, metadata, awsAwsjson11_deserializeOpErrorRenewDomain(response, &metadata) 2132 } 2133 output := &RenewDomainOutput{} 2134 out.Result = output 2135 2136 var buff [1024]byte 2137 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2138 2139 body := io.TeeReader(response.Body, ringBuffer) 2140 decoder := json.NewDecoder(body) 2141 decoder.UseNumber() 2142 var shape interface{} 2143 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2144 var snapshot bytes.Buffer 2145 io.Copy(&snapshot, ringBuffer) 2146 err = &smithy.DeserializationError{ 2147 Err: fmt.Errorf("failed to decode response body, %w", err), 2148 Snapshot: snapshot.Bytes(), 2149 } 2150 return out, metadata, err 2151 } 2152 2153 err = awsAwsjson11_deserializeOpDocumentRenewDomainOutput(&output, shape) 2154 if err != nil { 2155 var snapshot bytes.Buffer 2156 io.Copy(&snapshot, ringBuffer) 2157 err = &smithy.DeserializationError{ 2158 Err: fmt.Errorf("failed to decode response body, %w", err), 2159 Snapshot: snapshot.Bytes(), 2160 } 2161 return out, metadata, err 2162 } 2163 2164 return out, metadata, err 2165} 2166 2167func awsAwsjson11_deserializeOpErrorRenewDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2168 var errorBuffer bytes.Buffer 2169 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2170 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2171 } 2172 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2173 2174 errorCode := "UnknownError" 2175 errorMessage := errorCode 2176 2177 code := response.Header.Get("X-Amzn-ErrorType") 2178 if len(code) != 0 { 2179 errorCode = restjson.SanitizeErrorCode(code) 2180 } 2181 2182 var buff [1024]byte 2183 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2184 2185 body := io.TeeReader(errorBody, ringBuffer) 2186 decoder := json.NewDecoder(body) 2187 decoder.UseNumber() 2188 code, message, err := restjson.GetErrorInfo(decoder) 2189 if err != nil { 2190 var snapshot bytes.Buffer 2191 io.Copy(&snapshot, ringBuffer) 2192 err = &smithy.DeserializationError{ 2193 Err: fmt.Errorf("failed to decode response body, %w", err), 2194 Snapshot: snapshot.Bytes(), 2195 } 2196 return err 2197 } 2198 2199 errorBody.Seek(0, io.SeekStart) 2200 if len(code) != 0 { 2201 errorCode = restjson.SanitizeErrorCode(code) 2202 } 2203 if len(message) != 0 { 2204 errorMessage = message 2205 } 2206 2207 switch { 2208 case strings.EqualFold("DuplicateRequest", errorCode): 2209 return awsAwsjson11_deserializeErrorDuplicateRequest(response, errorBody) 2210 2211 case strings.EqualFold("InvalidInput", errorCode): 2212 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 2213 2214 case strings.EqualFold("OperationLimitExceeded", errorCode): 2215 return awsAwsjson11_deserializeErrorOperationLimitExceeded(response, errorBody) 2216 2217 case strings.EqualFold("TLDRulesViolation", errorCode): 2218 return awsAwsjson11_deserializeErrorTLDRulesViolation(response, errorBody) 2219 2220 case strings.EqualFold("UnsupportedTLD", errorCode): 2221 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 2222 2223 default: 2224 genericError := &smithy.GenericAPIError{ 2225 Code: errorCode, 2226 Message: errorMessage, 2227 } 2228 return genericError 2229 2230 } 2231} 2232 2233type awsAwsjson11_deserializeOpResendContactReachabilityEmail struct { 2234} 2235 2236func (*awsAwsjson11_deserializeOpResendContactReachabilityEmail) ID() string { 2237 return "OperationDeserializer" 2238} 2239 2240func (m *awsAwsjson11_deserializeOpResendContactReachabilityEmail) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2241 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2242) { 2243 out, metadata, err = next.HandleDeserialize(ctx, in) 2244 if err != nil { 2245 return out, metadata, err 2246 } 2247 2248 response, ok := out.RawResponse.(*smithyhttp.Response) 2249 if !ok { 2250 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2251 } 2252 2253 if response.StatusCode < 200 || response.StatusCode >= 300 { 2254 return out, metadata, awsAwsjson11_deserializeOpErrorResendContactReachabilityEmail(response, &metadata) 2255 } 2256 output := &ResendContactReachabilityEmailOutput{} 2257 out.Result = output 2258 2259 var buff [1024]byte 2260 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2261 2262 body := io.TeeReader(response.Body, ringBuffer) 2263 decoder := json.NewDecoder(body) 2264 decoder.UseNumber() 2265 var shape interface{} 2266 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2267 var snapshot bytes.Buffer 2268 io.Copy(&snapshot, ringBuffer) 2269 err = &smithy.DeserializationError{ 2270 Err: fmt.Errorf("failed to decode response body, %w", err), 2271 Snapshot: snapshot.Bytes(), 2272 } 2273 return out, metadata, err 2274 } 2275 2276 err = awsAwsjson11_deserializeOpDocumentResendContactReachabilityEmailOutput(&output, shape) 2277 if err != nil { 2278 var snapshot bytes.Buffer 2279 io.Copy(&snapshot, ringBuffer) 2280 err = &smithy.DeserializationError{ 2281 Err: fmt.Errorf("failed to decode response body, %w", err), 2282 Snapshot: snapshot.Bytes(), 2283 } 2284 return out, metadata, err 2285 } 2286 2287 return out, metadata, err 2288} 2289 2290func awsAwsjson11_deserializeOpErrorResendContactReachabilityEmail(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2291 var errorBuffer bytes.Buffer 2292 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2293 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2294 } 2295 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2296 2297 errorCode := "UnknownError" 2298 errorMessage := errorCode 2299 2300 code := response.Header.Get("X-Amzn-ErrorType") 2301 if len(code) != 0 { 2302 errorCode = restjson.SanitizeErrorCode(code) 2303 } 2304 2305 var buff [1024]byte 2306 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2307 2308 body := io.TeeReader(errorBody, ringBuffer) 2309 decoder := json.NewDecoder(body) 2310 decoder.UseNumber() 2311 code, message, err := restjson.GetErrorInfo(decoder) 2312 if err != nil { 2313 var snapshot bytes.Buffer 2314 io.Copy(&snapshot, ringBuffer) 2315 err = &smithy.DeserializationError{ 2316 Err: fmt.Errorf("failed to decode response body, %w", err), 2317 Snapshot: snapshot.Bytes(), 2318 } 2319 return err 2320 } 2321 2322 errorBody.Seek(0, io.SeekStart) 2323 if len(code) != 0 { 2324 errorCode = restjson.SanitizeErrorCode(code) 2325 } 2326 if len(message) != 0 { 2327 errorMessage = message 2328 } 2329 2330 switch { 2331 case strings.EqualFold("InvalidInput", errorCode): 2332 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 2333 2334 case strings.EqualFold("OperationLimitExceeded", errorCode): 2335 return awsAwsjson11_deserializeErrorOperationLimitExceeded(response, errorBody) 2336 2337 case strings.EqualFold("UnsupportedTLD", errorCode): 2338 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 2339 2340 default: 2341 genericError := &smithy.GenericAPIError{ 2342 Code: errorCode, 2343 Message: errorMessage, 2344 } 2345 return genericError 2346 2347 } 2348} 2349 2350type awsAwsjson11_deserializeOpRetrieveDomainAuthCode struct { 2351} 2352 2353func (*awsAwsjson11_deserializeOpRetrieveDomainAuthCode) ID() string { 2354 return "OperationDeserializer" 2355} 2356 2357func (m *awsAwsjson11_deserializeOpRetrieveDomainAuthCode) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2358 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2359) { 2360 out, metadata, err = next.HandleDeserialize(ctx, in) 2361 if err != nil { 2362 return out, metadata, err 2363 } 2364 2365 response, ok := out.RawResponse.(*smithyhttp.Response) 2366 if !ok { 2367 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2368 } 2369 2370 if response.StatusCode < 200 || response.StatusCode >= 300 { 2371 return out, metadata, awsAwsjson11_deserializeOpErrorRetrieveDomainAuthCode(response, &metadata) 2372 } 2373 output := &RetrieveDomainAuthCodeOutput{} 2374 out.Result = output 2375 2376 var buff [1024]byte 2377 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2378 2379 body := io.TeeReader(response.Body, ringBuffer) 2380 decoder := json.NewDecoder(body) 2381 decoder.UseNumber() 2382 var shape interface{} 2383 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2384 var snapshot bytes.Buffer 2385 io.Copy(&snapshot, ringBuffer) 2386 err = &smithy.DeserializationError{ 2387 Err: fmt.Errorf("failed to decode response body, %w", err), 2388 Snapshot: snapshot.Bytes(), 2389 } 2390 return out, metadata, err 2391 } 2392 2393 err = awsAwsjson11_deserializeOpDocumentRetrieveDomainAuthCodeOutput(&output, shape) 2394 if err != nil { 2395 var snapshot bytes.Buffer 2396 io.Copy(&snapshot, ringBuffer) 2397 err = &smithy.DeserializationError{ 2398 Err: fmt.Errorf("failed to decode response body, %w", err), 2399 Snapshot: snapshot.Bytes(), 2400 } 2401 return out, metadata, err 2402 } 2403 2404 return out, metadata, err 2405} 2406 2407func awsAwsjson11_deserializeOpErrorRetrieveDomainAuthCode(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2408 var errorBuffer bytes.Buffer 2409 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2410 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2411 } 2412 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2413 2414 errorCode := "UnknownError" 2415 errorMessage := errorCode 2416 2417 code := response.Header.Get("X-Amzn-ErrorType") 2418 if len(code) != 0 { 2419 errorCode = restjson.SanitizeErrorCode(code) 2420 } 2421 2422 var buff [1024]byte 2423 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2424 2425 body := io.TeeReader(errorBody, ringBuffer) 2426 decoder := json.NewDecoder(body) 2427 decoder.UseNumber() 2428 code, message, err := restjson.GetErrorInfo(decoder) 2429 if err != nil { 2430 var snapshot bytes.Buffer 2431 io.Copy(&snapshot, ringBuffer) 2432 err = &smithy.DeserializationError{ 2433 Err: fmt.Errorf("failed to decode response body, %w", err), 2434 Snapshot: snapshot.Bytes(), 2435 } 2436 return err 2437 } 2438 2439 errorBody.Seek(0, io.SeekStart) 2440 if len(code) != 0 { 2441 errorCode = restjson.SanitizeErrorCode(code) 2442 } 2443 if len(message) != 0 { 2444 errorMessage = message 2445 } 2446 2447 switch { 2448 case strings.EqualFold("InvalidInput", errorCode): 2449 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 2450 2451 case strings.EqualFold("UnsupportedTLD", errorCode): 2452 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 2453 2454 default: 2455 genericError := &smithy.GenericAPIError{ 2456 Code: errorCode, 2457 Message: errorMessage, 2458 } 2459 return genericError 2460 2461 } 2462} 2463 2464type awsAwsjson11_deserializeOpTransferDomain struct { 2465} 2466 2467func (*awsAwsjson11_deserializeOpTransferDomain) ID() string { 2468 return "OperationDeserializer" 2469} 2470 2471func (m *awsAwsjson11_deserializeOpTransferDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2472 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2473) { 2474 out, metadata, err = next.HandleDeserialize(ctx, in) 2475 if err != nil { 2476 return out, metadata, err 2477 } 2478 2479 response, ok := out.RawResponse.(*smithyhttp.Response) 2480 if !ok { 2481 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2482 } 2483 2484 if response.StatusCode < 200 || response.StatusCode >= 300 { 2485 return out, metadata, awsAwsjson11_deserializeOpErrorTransferDomain(response, &metadata) 2486 } 2487 output := &TransferDomainOutput{} 2488 out.Result = output 2489 2490 var buff [1024]byte 2491 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2492 2493 body := io.TeeReader(response.Body, ringBuffer) 2494 decoder := json.NewDecoder(body) 2495 decoder.UseNumber() 2496 var shape interface{} 2497 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2498 var snapshot bytes.Buffer 2499 io.Copy(&snapshot, ringBuffer) 2500 err = &smithy.DeserializationError{ 2501 Err: fmt.Errorf("failed to decode response body, %w", err), 2502 Snapshot: snapshot.Bytes(), 2503 } 2504 return out, metadata, err 2505 } 2506 2507 err = awsAwsjson11_deserializeOpDocumentTransferDomainOutput(&output, shape) 2508 if err != nil { 2509 var snapshot bytes.Buffer 2510 io.Copy(&snapshot, ringBuffer) 2511 err = &smithy.DeserializationError{ 2512 Err: fmt.Errorf("failed to decode response body, %w", err), 2513 Snapshot: snapshot.Bytes(), 2514 } 2515 return out, metadata, err 2516 } 2517 2518 return out, metadata, err 2519} 2520 2521func awsAwsjson11_deserializeOpErrorTransferDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2522 var errorBuffer bytes.Buffer 2523 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2524 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2525 } 2526 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2527 2528 errorCode := "UnknownError" 2529 errorMessage := errorCode 2530 2531 code := response.Header.Get("X-Amzn-ErrorType") 2532 if len(code) != 0 { 2533 errorCode = restjson.SanitizeErrorCode(code) 2534 } 2535 2536 var buff [1024]byte 2537 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2538 2539 body := io.TeeReader(errorBody, ringBuffer) 2540 decoder := json.NewDecoder(body) 2541 decoder.UseNumber() 2542 code, message, err := restjson.GetErrorInfo(decoder) 2543 if err != nil { 2544 var snapshot bytes.Buffer 2545 io.Copy(&snapshot, ringBuffer) 2546 err = &smithy.DeserializationError{ 2547 Err: fmt.Errorf("failed to decode response body, %w", err), 2548 Snapshot: snapshot.Bytes(), 2549 } 2550 return err 2551 } 2552 2553 errorBody.Seek(0, io.SeekStart) 2554 if len(code) != 0 { 2555 errorCode = restjson.SanitizeErrorCode(code) 2556 } 2557 if len(message) != 0 { 2558 errorMessage = message 2559 } 2560 2561 switch { 2562 case strings.EqualFold("DomainLimitExceeded", errorCode): 2563 return awsAwsjson11_deserializeErrorDomainLimitExceeded(response, errorBody) 2564 2565 case strings.EqualFold("DuplicateRequest", errorCode): 2566 return awsAwsjson11_deserializeErrorDuplicateRequest(response, errorBody) 2567 2568 case strings.EqualFold("InvalidInput", errorCode): 2569 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 2570 2571 case strings.EqualFold("OperationLimitExceeded", errorCode): 2572 return awsAwsjson11_deserializeErrorOperationLimitExceeded(response, errorBody) 2573 2574 case strings.EqualFold("TLDRulesViolation", errorCode): 2575 return awsAwsjson11_deserializeErrorTLDRulesViolation(response, errorBody) 2576 2577 case strings.EqualFold("UnsupportedTLD", errorCode): 2578 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 2579 2580 default: 2581 genericError := &smithy.GenericAPIError{ 2582 Code: errorCode, 2583 Message: errorMessage, 2584 } 2585 return genericError 2586 2587 } 2588} 2589 2590type awsAwsjson11_deserializeOpTransferDomainToAnotherAwsAccount struct { 2591} 2592 2593func (*awsAwsjson11_deserializeOpTransferDomainToAnotherAwsAccount) ID() string { 2594 return "OperationDeserializer" 2595} 2596 2597func (m *awsAwsjson11_deserializeOpTransferDomainToAnotherAwsAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2598 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2599) { 2600 out, metadata, err = next.HandleDeserialize(ctx, in) 2601 if err != nil { 2602 return out, metadata, err 2603 } 2604 2605 response, ok := out.RawResponse.(*smithyhttp.Response) 2606 if !ok { 2607 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2608 } 2609 2610 if response.StatusCode < 200 || response.StatusCode >= 300 { 2611 return out, metadata, awsAwsjson11_deserializeOpErrorTransferDomainToAnotherAwsAccount(response, &metadata) 2612 } 2613 output := &TransferDomainToAnotherAwsAccountOutput{} 2614 out.Result = output 2615 2616 var buff [1024]byte 2617 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2618 2619 body := io.TeeReader(response.Body, ringBuffer) 2620 decoder := json.NewDecoder(body) 2621 decoder.UseNumber() 2622 var shape interface{} 2623 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2624 var snapshot bytes.Buffer 2625 io.Copy(&snapshot, ringBuffer) 2626 err = &smithy.DeserializationError{ 2627 Err: fmt.Errorf("failed to decode response body, %w", err), 2628 Snapshot: snapshot.Bytes(), 2629 } 2630 return out, metadata, err 2631 } 2632 2633 err = awsAwsjson11_deserializeOpDocumentTransferDomainToAnotherAwsAccountOutput(&output, shape) 2634 if err != nil { 2635 var snapshot bytes.Buffer 2636 io.Copy(&snapshot, ringBuffer) 2637 err = &smithy.DeserializationError{ 2638 Err: fmt.Errorf("failed to decode response body, %w", err), 2639 Snapshot: snapshot.Bytes(), 2640 } 2641 return out, metadata, err 2642 } 2643 2644 return out, metadata, err 2645} 2646 2647func awsAwsjson11_deserializeOpErrorTransferDomainToAnotherAwsAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2648 var errorBuffer bytes.Buffer 2649 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2650 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2651 } 2652 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2653 2654 errorCode := "UnknownError" 2655 errorMessage := errorCode 2656 2657 code := response.Header.Get("X-Amzn-ErrorType") 2658 if len(code) != 0 { 2659 errorCode = restjson.SanitizeErrorCode(code) 2660 } 2661 2662 var buff [1024]byte 2663 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2664 2665 body := io.TeeReader(errorBody, ringBuffer) 2666 decoder := json.NewDecoder(body) 2667 decoder.UseNumber() 2668 code, message, err := restjson.GetErrorInfo(decoder) 2669 if err != nil { 2670 var snapshot bytes.Buffer 2671 io.Copy(&snapshot, ringBuffer) 2672 err = &smithy.DeserializationError{ 2673 Err: fmt.Errorf("failed to decode response body, %w", err), 2674 Snapshot: snapshot.Bytes(), 2675 } 2676 return err 2677 } 2678 2679 errorBody.Seek(0, io.SeekStart) 2680 if len(code) != 0 { 2681 errorCode = restjson.SanitizeErrorCode(code) 2682 } 2683 if len(message) != 0 { 2684 errorMessage = message 2685 } 2686 2687 switch { 2688 case strings.EqualFold("DuplicateRequest", errorCode): 2689 return awsAwsjson11_deserializeErrorDuplicateRequest(response, errorBody) 2690 2691 case strings.EqualFold("InvalidInput", errorCode): 2692 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 2693 2694 case strings.EqualFold("OperationLimitExceeded", errorCode): 2695 return awsAwsjson11_deserializeErrorOperationLimitExceeded(response, errorBody) 2696 2697 default: 2698 genericError := &smithy.GenericAPIError{ 2699 Code: errorCode, 2700 Message: errorMessage, 2701 } 2702 return genericError 2703 2704 } 2705} 2706 2707type awsAwsjson11_deserializeOpUpdateDomainContact struct { 2708} 2709 2710func (*awsAwsjson11_deserializeOpUpdateDomainContact) ID() string { 2711 return "OperationDeserializer" 2712} 2713 2714func (m *awsAwsjson11_deserializeOpUpdateDomainContact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2715 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2716) { 2717 out, metadata, err = next.HandleDeserialize(ctx, in) 2718 if err != nil { 2719 return out, metadata, err 2720 } 2721 2722 response, ok := out.RawResponse.(*smithyhttp.Response) 2723 if !ok { 2724 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2725 } 2726 2727 if response.StatusCode < 200 || response.StatusCode >= 300 { 2728 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateDomainContact(response, &metadata) 2729 } 2730 output := &UpdateDomainContactOutput{} 2731 out.Result = output 2732 2733 var buff [1024]byte 2734 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2735 2736 body := io.TeeReader(response.Body, ringBuffer) 2737 decoder := json.NewDecoder(body) 2738 decoder.UseNumber() 2739 var shape interface{} 2740 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2741 var snapshot bytes.Buffer 2742 io.Copy(&snapshot, ringBuffer) 2743 err = &smithy.DeserializationError{ 2744 Err: fmt.Errorf("failed to decode response body, %w", err), 2745 Snapshot: snapshot.Bytes(), 2746 } 2747 return out, metadata, err 2748 } 2749 2750 err = awsAwsjson11_deserializeOpDocumentUpdateDomainContactOutput(&output, shape) 2751 if err != nil { 2752 var snapshot bytes.Buffer 2753 io.Copy(&snapshot, ringBuffer) 2754 err = &smithy.DeserializationError{ 2755 Err: fmt.Errorf("failed to decode response body, %w", err), 2756 Snapshot: snapshot.Bytes(), 2757 } 2758 return out, metadata, err 2759 } 2760 2761 return out, metadata, err 2762} 2763 2764func awsAwsjson11_deserializeOpErrorUpdateDomainContact(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2765 var errorBuffer bytes.Buffer 2766 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2767 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2768 } 2769 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2770 2771 errorCode := "UnknownError" 2772 errorMessage := errorCode 2773 2774 code := response.Header.Get("X-Amzn-ErrorType") 2775 if len(code) != 0 { 2776 errorCode = restjson.SanitizeErrorCode(code) 2777 } 2778 2779 var buff [1024]byte 2780 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2781 2782 body := io.TeeReader(errorBody, ringBuffer) 2783 decoder := json.NewDecoder(body) 2784 decoder.UseNumber() 2785 code, message, err := restjson.GetErrorInfo(decoder) 2786 if err != nil { 2787 var snapshot bytes.Buffer 2788 io.Copy(&snapshot, ringBuffer) 2789 err = &smithy.DeserializationError{ 2790 Err: fmt.Errorf("failed to decode response body, %w", err), 2791 Snapshot: snapshot.Bytes(), 2792 } 2793 return err 2794 } 2795 2796 errorBody.Seek(0, io.SeekStart) 2797 if len(code) != 0 { 2798 errorCode = restjson.SanitizeErrorCode(code) 2799 } 2800 if len(message) != 0 { 2801 errorMessage = message 2802 } 2803 2804 switch { 2805 case strings.EqualFold("DuplicateRequest", errorCode): 2806 return awsAwsjson11_deserializeErrorDuplicateRequest(response, errorBody) 2807 2808 case strings.EqualFold("InvalidInput", errorCode): 2809 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 2810 2811 case strings.EqualFold("OperationLimitExceeded", errorCode): 2812 return awsAwsjson11_deserializeErrorOperationLimitExceeded(response, errorBody) 2813 2814 case strings.EqualFold("TLDRulesViolation", errorCode): 2815 return awsAwsjson11_deserializeErrorTLDRulesViolation(response, errorBody) 2816 2817 case strings.EqualFold("UnsupportedTLD", errorCode): 2818 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 2819 2820 default: 2821 genericError := &smithy.GenericAPIError{ 2822 Code: errorCode, 2823 Message: errorMessage, 2824 } 2825 return genericError 2826 2827 } 2828} 2829 2830type awsAwsjson11_deserializeOpUpdateDomainContactPrivacy struct { 2831} 2832 2833func (*awsAwsjson11_deserializeOpUpdateDomainContactPrivacy) ID() string { 2834 return "OperationDeserializer" 2835} 2836 2837func (m *awsAwsjson11_deserializeOpUpdateDomainContactPrivacy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2838 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2839) { 2840 out, metadata, err = next.HandleDeserialize(ctx, in) 2841 if err != nil { 2842 return out, metadata, err 2843 } 2844 2845 response, ok := out.RawResponse.(*smithyhttp.Response) 2846 if !ok { 2847 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2848 } 2849 2850 if response.StatusCode < 200 || response.StatusCode >= 300 { 2851 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateDomainContactPrivacy(response, &metadata) 2852 } 2853 output := &UpdateDomainContactPrivacyOutput{} 2854 out.Result = output 2855 2856 var buff [1024]byte 2857 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2858 2859 body := io.TeeReader(response.Body, ringBuffer) 2860 decoder := json.NewDecoder(body) 2861 decoder.UseNumber() 2862 var shape interface{} 2863 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2864 var snapshot bytes.Buffer 2865 io.Copy(&snapshot, ringBuffer) 2866 err = &smithy.DeserializationError{ 2867 Err: fmt.Errorf("failed to decode response body, %w", err), 2868 Snapshot: snapshot.Bytes(), 2869 } 2870 return out, metadata, err 2871 } 2872 2873 err = awsAwsjson11_deserializeOpDocumentUpdateDomainContactPrivacyOutput(&output, shape) 2874 if err != nil { 2875 var snapshot bytes.Buffer 2876 io.Copy(&snapshot, ringBuffer) 2877 err = &smithy.DeserializationError{ 2878 Err: fmt.Errorf("failed to decode response body, %w", err), 2879 Snapshot: snapshot.Bytes(), 2880 } 2881 return out, metadata, err 2882 } 2883 2884 return out, metadata, err 2885} 2886 2887func awsAwsjson11_deserializeOpErrorUpdateDomainContactPrivacy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2888 var errorBuffer bytes.Buffer 2889 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2890 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2891 } 2892 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2893 2894 errorCode := "UnknownError" 2895 errorMessage := errorCode 2896 2897 code := response.Header.Get("X-Amzn-ErrorType") 2898 if len(code) != 0 { 2899 errorCode = restjson.SanitizeErrorCode(code) 2900 } 2901 2902 var buff [1024]byte 2903 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2904 2905 body := io.TeeReader(errorBody, ringBuffer) 2906 decoder := json.NewDecoder(body) 2907 decoder.UseNumber() 2908 code, message, err := restjson.GetErrorInfo(decoder) 2909 if err != nil { 2910 var snapshot bytes.Buffer 2911 io.Copy(&snapshot, ringBuffer) 2912 err = &smithy.DeserializationError{ 2913 Err: fmt.Errorf("failed to decode response body, %w", err), 2914 Snapshot: snapshot.Bytes(), 2915 } 2916 return err 2917 } 2918 2919 errorBody.Seek(0, io.SeekStart) 2920 if len(code) != 0 { 2921 errorCode = restjson.SanitizeErrorCode(code) 2922 } 2923 if len(message) != 0 { 2924 errorMessage = message 2925 } 2926 2927 switch { 2928 case strings.EqualFold("DuplicateRequest", errorCode): 2929 return awsAwsjson11_deserializeErrorDuplicateRequest(response, errorBody) 2930 2931 case strings.EqualFold("InvalidInput", errorCode): 2932 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 2933 2934 case strings.EqualFold("OperationLimitExceeded", errorCode): 2935 return awsAwsjson11_deserializeErrorOperationLimitExceeded(response, errorBody) 2936 2937 case strings.EqualFold("TLDRulesViolation", errorCode): 2938 return awsAwsjson11_deserializeErrorTLDRulesViolation(response, errorBody) 2939 2940 case strings.EqualFold("UnsupportedTLD", errorCode): 2941 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 2942 2943 default: 2944 genericError := &smithy.GenericAPIError{ 2945 Code: errorCode, 2946 Message: errorMessage, 2947 } 2948 return genericError 2949 2950 } 2951} 2952 2953type awsAwsjson11_deserializeOpUpdateDomainNameservers struct { 2954} 2955 2956func (*awsAwsjson11_deserializeOpUpdateDomainNameservers) ID() string { 2957 return "OperationDeserializer" 2958} 2959 2960func (m *awsAwsjson11_deserializeOpUpdateDomainNameservers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2961 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2962) { 2963 out, metadata, err = next.HandleDeserialize(ctx, in) 2964 if err != nil { 2965 return out, metadata, err 2966 } 2967 2968 response, ok := out.RawResponse.(*smithyhttp.Response) 2969 if !ok { 2970 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2971 } 2972 2973 if response.StatusCode < 200 || response.StatusCode >= 300 { 2974 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateDomainNameservers(response, &metadata) 2975 } 2976 output := &UpdateDomainNameserversOutput{} 2977 out.Result = output 2978 2979 var buff [1024]byte 2980 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2981 2982 body := io.TeeReader(response.Body, ringBuffer) 2983 decoder := json.NewDecoder(body) 2984 decoder.UseNumber() 2985 var shape interface{} 2986 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2987 var snapshot bytes.Buffer 2988 io.Copy(&snapshot, ringBuffer) 2989 err = &smithy.DeserializationError{ 2990 Err: fmt.Errorf("failed to decode response body, %w", err), 2991 Snapshot: snapshot.Bytes(), 2992 } 2993 return out, metadata, err 2994 } 2995 2996 err = awsAwsjson11_deserializeOpDocumentUpdateDomainNameserversOutput(&output, shape) 2997 if err != nil { 2998 var snapshot bytes.Buffer 2999 io.Copy(&snapshot, ringBuffer) 3000 err = &smithy.DeserializationError{ 3001 Err: fmt.Errorf("failed to decode response body, %w", err), 3002 Snapshot: snapshot.Bytes(), 3003 } 3004 return out, metadata, err 3005 } 3006 3007 return out, metadata, err 3008} 3009 3010func awsAwsjson11_deserializeOpErrorUpdateDomainNameservers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3011 var errorBuffer bytes.Buffer 3012 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3013 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3014 } 3015 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3016 3017 errorCode := "UnknownError" 3018 errorMessage := errorCode 3019 3020 code := response.Header.Get("X-Amzn-ErrorType") 3021 if len(code) != 0 { 3022 errorCode = restjson.SanitizeErrorCode(code) 3023 } 3024 3025 var buff [1024]byte 3026 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3027 3028 body := io.TeeReader(errorBody, ringBuffer) 3029 decoder := json.NewDecoder(body) 3030 decoder.UseNumber() 3031 code, message, err := restjson.GetErrorInfo(decoder) 3032 if err != nil { 3033 var snapshot bytes.Buffer 3034 io.Copy(&snapshot, ringBuffer) 3035 err = &smithy.DeserializationError{ 3036 Err: fmt.Errorf("failed to decode response body, %w", err), 3037 Snapshot: snapshot.Bytes(), 3038 } 3039 return err 3040 } 3041 3042 errorBody.Seek(0, io.SeekStart) 3043 if len(code) != 0 { 3044 errorCode = restjson.SanitizeErrorCode(code) 3045 } 3046 if len(message) != 0 { 3047 errorMessage = message 3048 } 3049 3050 switch { 3051 case strings.EqualFold("DuplicateRequest", errorCode): 3052 return awsAwsjson11_deserializeErrorDuplicateRequest(response, errorBody) 3053 3054 case strings.EqualFold("InvalidInput", errorCode): 3055 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 3056 3057 case strings.EqualFold("OperationLimitExceeded", errorCode): 3058 return awsAwsjson11_deserializeErrorOperationLimitExceeded(response, errorBody) 3059 3060 case strings.EqualFold("TLDRulesViolation", errorCode): 3061 return awsAwsjson11_deserializeErrorTLDRulesViolation(response, errorBody) 3062 3063 case strings.EqualFold("UnsupportedTLD", errorCode): 3064 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 3065 3066 default: 3067 genericError := &smithy.GenericAPIError{ 3068 Code: errorCode, 3069 Message: errorMessage, 3070 } 3071 return genericError 3072 3073 } 3074} 3075 3076type awsAwsjson11_deserializeOpUpdateTagsForDomain struct { 3077} 3078 3079func (*awsAwsjson11_deserializeOpUpdateTagsForDomain) ID() string { 3080 return "OperationDeserializer" 3081} 3082 3083func (m *awsAwsjson11_deserializeOpUpdateTagsForDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3084 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3085) { 3086 out, metadata, err = next.HandleDeserialize(ctx, in) 3087 if err != nil { 3088 return out, metadata, err 3089 } 3090 3091 response, ok := out.RawResponse.(*smithyhttp.Response) 3092 if !ok { 3093 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3094 } 3095 3096 if response.StatusCode < 200 || response.StatusCode >= 300 { 3097 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateTagsForDomain(response, &metadata) 3098 } 3099 output := &UpdateTagsForDomainOutput{} 3100 out.Result = output 3101 3102 var buff [1024]byte 3103 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3104 3105 body := io.TeeReader(response.Body, ringBuffer) 3106 decoder := json.NewDecoder(body) 3107 decoder.UseNumber() 3108 var shape interface{} 3109 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3110 var snapshot bytes.Buffer 3111 io.Copy(&snapshot, ringBuffer) 3112 err = &smithy.DeserializationError{ 3113 Err: fmt.Errorf("failed to decode response body, %w", err), 3114 Snapshot: snapshot.Bytes(), 3115 } 3116 return out, metadata, err 3117 } 3118 3119 err = awsAwsjson11_deserializeOpDocumentUpdateTagsForDomainOutput(&output, shape) 3120 if err != nil { 3121 var snapshot bytes.Buffer 3122 io.Copy(&snapshot, ringBuffer) 3123 err = &smithy.DeserializationError{ 3124 Err: fmt.Errorf("failed to decode response body, %w", err), 3125 Snapshot: snapshot.Bytes(), 3126 } 3127 return out, metadata, err 3128 } 3129 3130 return out, metadata, err 3131} 3132 3133func awsAwsjson11_deserializeOpErrorUpdateTagsForDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3134 var errorBuffer bytes.Buffer 3135 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3136 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3137 } 3138 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3139 3140 errorCode := "UnknownError" 3141 errorMessage := errorCode 3142 3143 code := response.Header.Get("X-Amzn-ErrorType") 3144 if len(code) != 0 { 3145 errorCode = restjson.SanitizeErrorCode(code) 3146 } 3147 3148 var buff [1024]byte 3149 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3150 3151 body := io.TeeReader(errorBody, ringBuffer) 3152 decoder := json.NewDecoder(body) 3153 decoder.UseNumber() 3154 code, message, err := restjson.GetErrorInfo(decoder) 3155 if err != nil { 3156 var snapshot bytes.Buffer 3157 io.Copy(&snapshot, ringBuffer) 3158 err = &smithy.DeserializationError{ 3159 Err: fmt.Errorf("failed to decode response body, %w", err), 3160 Snapshot: snapshot.Bytes(), 3161 } 3162 return err 3163 } 3164 3165 errorBody.Seek(0, io.SeekStart) 3166 if len(code) != 0 { 3167 errorCode = restjson.SanitizeErrorCode(code) 3168 } 3169 if len(message) != 0 { 3170 errorMessage = message 3171 } 3172 3173 switch { 3174 case strings.EqualFold("InvalidInput", errorCode): 3175 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 3176 3177 case strings.EqualFold("OperationLimitExceeded", errorCode): 3178 return awsAwsjson11_deserializeErrorOperationLimitExceeded(response, errorBody) 3179 3180 case strings.EqualFold("UnsupportedTLD", errorCode): 3181 return awsAwsjson11_deserializeErrorUnsupportedTLD(response, errorBody) 3182 3183 default: 3184 genericError := &smithy.GenericAPIError{ 3185 Code: errorCode, 3186 Message: errorMessage, 3187 } 3188 return genericError 3189 3190 } 3191} 3192 3193type awsAwsjson11_deserializeOpViewBilling struct { 3194} 3195 3196func (*awsAwsjson11_deserializeOpViewBilling) ID() string { 3197 return "OperationDeserializer" 3198} 3199 3200func (m *awsAwsjson11_deserializeOpViewBilling) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3201 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3202) { 3203 out, metadata, err = next.HandleDeserialize(ctx, in) 3204 if err != nil { 3205 return out, metadata, err 3206 } 3207 3208 response, ok := out.RawResponse.(*smithyhttp.Response) 3209 if !ok { 3210 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3211 } 3212 3213 if response.StatusCode < 200 || response.StatusCode >= 300 { 3214 return out, metadata, awsAwsjson11_deserializeOpErrorViewBilling(response, &metadata) 3215 } 3216 output := &ViewBillingOutput{} 3217 out.Result = output 3218 3219 var buff [1024]byte 3220 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3221 3222 body := io.TeeReader(response.Body, ringBuffer) 3223 decoder := json.NewDecoder(body) 3224 decoder.UseNumber() 3225 var shape interface{} 3226 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3227 var snapshot bytes.Buffer 3228 io.Copy(&snapshot, ringBuffer) 3229 err = &smithy.DeserializationError{ 3230 Err: fmt.Errorf("failed to decode response body, %w", err), 3231 Snapshot: snapshot.Bytes(), 3232 } 3233 return out, metadata, err 3234 } 3235 3236 err = awsAwsjson11_deserializeOpDocumentViewBillingOutput(&output, shape) 3237 if err != nil { 3238 var snapshot bytes.Buffer 3239 io.Copy(&snapshot, ringBuffer) 3240 err = &smithy.DeserializationError{ 3241 Err: fmt.Errorf("failed to decode response body, %w", err), 3242 Snapshot: snapshot.Bytes(), 3243 } 3244 return out, metadata, err 3245 } 3246 3247 return out, metadata, err 3248} 3249 3250func awsAwsjson11_deserializeOpErrorViewBilling(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3251 var errorBuffer bytes.Buffer 3252 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3253 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3254 } 3255 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3256 3257 errorCode := "UnknownError" 3258 errorMessage := errorCode 3259 3260 code := response.Header.Get("X-Amzn-ErrorType") 3261 if len(code) != 0 { 3262 errorCode = restjson.SanitizeErrorCode(code) 3263 } 3264 3265 var buff [1024]byte 3266 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3267 3268 body := io.TeeReader(errorBody, ringBuffer) 3269 decoder := json.NewDecoder(body) 3270 decoder.UseNumber() 3271 code, message, err := restjson.GetErrorInfo(decoder) 3272 if err != nil { 3273 var snapshot bytes.Buffer 3274 io.Copy(&snapshot, ringBuffer) 3275 err = &smithy.DeserializationError{ 3276 Err: fmt.Errorf("failed to decode response body, %w", err), 3277 Snapshot: snapshot.Bytes(), 3278 } 3279 return err 3280 } 3281 3282 errorBody.Seek(0, io.SeekStart) 3283 if len(code) != 0 { 3284 errorCode = restjson.SanitizeErrorCode(code) 3285 } 3286 if len(message) != 0 { 3287 errorMessage = message 3288 } 3289 3290 switch { 3291 case strings.EqualFold("InvalidInput", errorCode): 3292 return awsAwsjson11_deserializeErrorInvalidInput(response, errorBody) 3293 3294 default: 3295 genericError := &smithy.GenericAPIError{ 3296 Code: errorCode, 3297 Message: errorMessage, 3298 } 3299 return genericError 3300 3301 } 3302} 3303 3304func awsAwsjson11_deserializeErrorDomainLimitExceeded(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3305 var buff [1024]byte 3306 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3307 3308 body := io.TeeReader(errorBody, ringBuffer) 3309 decoder := json.NewDecoder(body) 3310 decoder.UseNumber() 3311 var shape interface{} 3312 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3313 var snapshot bytes.Buffer 3314 io.Copy(&snapshot, ringBuffer) 3315 err = &smithy.DeserializationError{ 3316 Err: fmt.Errorf("failed to decode response body, %w", err), 3317 Snapshot: snapshot.Bytes(), 3318 } 3319 return err 3320 } 3321 3322 output := &types.DomainLimitExceeded{} 3323 err := awsAwsjson11_deserializeDocumentDomainLimitExceeded(&output, shape) 3324 3325 if err != nil { 3326 var snapshot bytes.Buffer 3327 io.Copy(&snapshot, ringBuffer) 3328 err = &smithy.DeserializationError{ 3329 Err: fmt.Errorf("failed to decode response body, %w", err), 3330 Snapshot: snapshot.Bytes(), 3331 } 3332 return err 3333 } 3334 3335 errorBody.Seek(0, io.SeekStart) 3336 return output 3337} 3338 3339func awsAwsjson11_deserializeErrorDuplicateRequest(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3340 var buff [1024]byte 3341 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3342 3343 body := io.TeeReader(errorBody, ringBuffer) 3344 decoder := json.NewDecoder(body) 3345 decoder.UseNumber() 3346 var shape interface{} 3347 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3348 var snapshot bytes.Buffer 3349 io.Copy(&snapshot, ringBuffer) 3350 err = &smithy.DeserializationError{ 3351 Err: fmt.Errorf("failed to decode response body, %w", err), 3352 Snapshot: snapshot.Bytes(), 3353 } 3354 return err 3355 } 3356 3357 output := &types.DuplicateRequest{} 3358 err := awsAwsjson11_deserializeDocumentDuplicateRequest(&output, shape) 3359 3360 if err != nil { 3361 var snapshot bytes.Buffer 3362 io.Copy(&snapshot, ringBuffer) 3363 err = &smithy.DeserializationError{ 3364 Err: fmt.Errorf("failed to decode response body, %w", err), 3365 Snapshot: snapshot.Bytes(), 3366 } 3367 return err 3368 } 3369 3370 errorBody.Seek(0, io.SeekStart) 3371 return output 3372} 3373 3374func awsAwsjson11_deserializeErrorInvalidInput(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3375 var buff [1024]byte 3376 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3377 3378 body := io.TeeReader(errorBody, ringBuffer) 3379 decoder := json.NewDecoder(body) 3380 decoder.UseNumber() 3381 var shape interface{} 3382 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3383 var snapshot bytes.Buffer 3384 io.Copy(&snapshot, ringBuffer) 3385 err = &smithy.DeserializationError{ 3386 Err: fmt.Errorf("failed to decode response body, %w", err), 3387 Snapshot: snapshot.Bytes(), 3388 } 3389 return err 3390 } 3391 3392 output := &types.InvalidInput{} 3393 err := awsAwsjson11_deserializeDocumentInvalidInput(&output, shape) 3394 3395 if err != nil { 3396 var snapshot bytes.Buffer 3397 io.Copy(&snapshot, ringBuffer) 3398 err = &smithy.DeserializationError{ 3399 Err: fmt.Errorf("failed to decode response body, %w", err), 3400 Snapshot: snapshot.Bytes(), 3401 } 3402 return err 3403 } 3404 3405 errorBody.Seek(0, io.SeekStart) 3406 return output 3407} 3408 3409func awsAwsjson11_deserializeErrorOperationLimitExceeded(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3410 var buff [1024]byte 3411 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3412 3413 body := io.TeeReader(errorBody, ringBuffer) 3414 decoder := json.NewDecoder(body) 3415 decoder.UseNumber() 3416 var shape interface{} 3417 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3418 var snapshot bytes.Buffer 3419 io.Copy(&snapshot, ringBuffer) 3420 err = &smithy.DeserializationError{ 3421 Err: fmt.Errorf("failed to decode response body, %w", err), 3422 Snapshot: snapshot.Bytes(), 3423 } 3424 return err 3425 } 3426 3427 output := &types.OperationLimitExceeded{} 3428 err := awsAwsjson11_deserializeDocumentOperationLimitExceeded(&output, shape) 3429 3430 if err != nil { 3431 var snapshot bytes.Buffer 3432 io.Copy(&snapshot, ringBuffer) 3433 err = &smithy.DeserializationError{ 3434 Err: fmt.Errorf("failed to decode response body, %w", err), 3435 Snapshot: snapshot.Bytes(), 3436 } 3437 return err 3438 } 3439 3440 errorBody.Seek(0, io.SeekStart) 3441 return output 3442} 3443 3444func awsAwsjson11_deserializeErrorTLDRulesViolation(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3445 var buff [1024]byte 3446 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3447 3448 body := io.TeeReader(errorBody, ringBuffer) 3449 decoder := json.NewDecoder(body) 3450 decoder.UseNumber() 3451 var shape interface{} 3452 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3453 var snapshot bytes.Buffer 3454 io.Copy(&snapshot, ringBuffer) 3455 err = &smithy.DeserializationError{ 3456 Err: fmt.Errorf("failed to decode response body, %w", err), 3457 Snapshot: snapshot.Bytes(), 3458 } 3459 return err 3460 } 3461 3462 output := &types.TLDRulesViolation{} 3463 err := awsAwsjson11_deserializeDocumentTLDRulesViolation(&output, shape) 3464 3465 if err != nil { 3466 var snapshot bytes.Buffer 3467 io.Copy(&snapshot, ringBuffer) 3468 err = &smithy.DeserializationError{ 3469 Err: fmt.Errorf("failed to decode response body, %w", err), 3470 Snapshot: snapshot.Bytes(), 3471 } 3472 return err 3473 } 3474 3475 errorBody.Seek(0, io.SeekStart) 3476 return output 3477} 3478 3479func awsAwsjson11_deserializeErrorUnsupportedTLD(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3480 var buff [1024]byte 3481 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3482 3483 body := io.TeeReader(errorBody, ringBuffer) 3484 decoder := json.NewDecoder(body) 3485 decoder.UseNumber() 3486 var shape interface{} 3487 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3488 var snapshot bytes.Buffer 3489 io.Copy(&snapshot, ringBuffer) 3490 err = &smithy.DeserializationError{ 3491 Err: fmt.Errorf("failed to decode response body, %w", err), 3492 Snapshot: snapshot.Bytes(), 3493 } 3494 return err 3495 } 3496 3497 output := &types.UnsupportedTLD{} 3498 err := awsAwsjson11_deserializeDocumentUnsupportedTLD(&output, shape) 3499 3500 if err != nil { 3501 var snapshot bytes.Buffer 3502 io.Copy(&snapshot, ringBuffer) 3503 err = &smithy.DeserializationError{ 3504 Err: fmt.Errorf("failed to decode response body, %w", err), 3505 Snapshot: snapshot.Bytes(), 3506 } 3507 return err 3508 } 3509 3510 errorBody.Seek(0, io.SeekStart) 3511 return output 3512} 3513 3514func awsAwsjson11_deserializeDocumentBillingRecord(v **types.BillingRecord, value interface{}) error { 3515 if v == nil { 3516 return fmt.Errorf("unexpected nil of type %T", v) 3517 } 3518 if value == nil { 3519 return nil 3520 } 3521 3522 shape, ok := value.(map[string]interface{}) 3523 if !ok { 3524 return fmt.Errorf("unexpected JSON type %v", value) 3525 } 3526 3527 var sv *types.BillingRecord 3528 if *v == nil { 3529 sv = &types.BillingRecord{} 3530 } else { 3531 sv = *v 3532 } 3533 3534 for key, value := range shape { 3535 switch key { 3536 case "BillDate": 3537 if value != nil { 3538 jtv, ok := value.(json.Number) 3539 if !ok { 3540 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 3541 } 3542 f64, err := jtv.Float64() 3543 if err != nil { 3544 return err 3545 } 3546 sv.BillDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3547 } 3548 3549 case "DomainName": 3550 if value != nil { 3551 jtv, ok := value.(string) 3552 if !ok { 3553 return fmt.Errorf("expected DomainName to be of type string, got %T instead", value) 3554 } 3555 sv.DomainName = ptr.String(jtv) 3556 } 3557 3558 case "InvoiceId": 3559 if value != nil { 3560 jtv, ok := value.(string) 3561 if !ok { 3562 return fmt.Errorf("expected InvoiceId to be of type string, got %T instead", value) 3563 } 3564 sv.InvoiceId = ptr.String(jtv) 3565 } 3566 3567 case "Operation": 3568 if value != nil { 3569 jtv, ok := value.(string) 3570 if !ok { 3571 return fmt.Errorf("expected OperationType to be of type string, got %T instead", value) 3572 } 3573 sv.Operation = types.OperationType(jtv) 3574 } 3575 3576 case "Price": 3577 if value != nil { 3578 jtv, ok := value.(json.Number) 3579 if !ok { 3580 return fmt.Errorf("expected Price to be json.Number, got %T instead", value) 3581 } 3582 f64, err := jtv.Float64() 3583 if err != nil { 3584 return err 3585 } 3586 sv.Price = f64 3587 } 3588 3589 default: 3590 _, _ = key, value 3591 3592 } 3593 } 3594 *v = sv 3595 return nil 3596} 3597 3598func awsAwsjson11_deserializeDocumentBillingRecords(v *[]types.BillingRecord, value interface{}) error { 3599 if v == nil { 3600 return fmt.Errorf("unexpected nil of type %T", v) 3601 } 3602 if value == nil { 3603 return nil 3604 } 3605 3606 shape, ok := value.([]interface{}) 3607 if !ok { 3608 return fmt.Errorf("unexpected JSON type %v", value) 3609 } 3610 3611 var cv []types.BillingRecord 3612 if *v == nil { 3613 cv = []types.BillingRecord{} 3614 } else { 3615 cv = *v 3616 } 3617 3618 for _, value := range shape { 3619 var col types.BillingRecord 3620 destAddr := &col 3621 if err := awsAwsjson11_deserializeDocumentBillingRecord(&destAddr, value); err != nil { 3622 return err 3623 } 3624 col = *destAddr 3625 cv = append(cv, col) 3626 3627 } 3628 *v = cv 3629 return nil 3630} 3631 3632func awsAwsjson11_deserializeDocumentContactDetail(v **types.ContactDetail, value interface{}) error { 3633 if v == nil { 3634 return fmt.Errorf("unexpected nil of type %T", v) 3635 } 3636 if value == nil { 3637 return nil 3638 } 3639 3640 shape, ok := value.(map[string]interface{}) 3641 if !ok { 3642 return fmt.Errorf("unexpected JSON type %v", value) 3643 } 3644 3645 var sv *types.ContactDetail 3646 if *v == nil { 3647 sv = &types.ContactDetail{} 3648 } else { 3649 sv = *v 3650 } 3651 3652 for key, value := range shape { 3653 switch key { 3654 case "AddressLine1": 3655 if value != nil { 3656 jtv, ok := value.(string) 3657 if !ok { 3658 return fmt.Errorf("expected AddressLine to be of type string, got %T instead", value) 3659 } 3660 sv.AddressLine1 = ptr.String(jtv) 3661 } 3662 3663 case "AddressLine2": 3664 if value != nil { 3665 jtv, ok := value.(string) 3666 if !ok { 3667 return fmt.Errorf("expected AddressLine to be of type string, got %T instead", value) 3668 } 3669 sv.AddressLine2 = ptr.String(jtv) 3670 } 3671 3672 case "City": 3673 if value != nil { 3674 jtv, ok := value.(string) 3675 if !ok { 3676 return fmt.Errorf("expected City to be of type string, got %T instead", value) 3677 } 3678 sv.City = ptr.String(jtv) 3679 } 3680 3681 case "ContactType": 3682 if value != nil { 3683 jtv, ok := value.(string) 3684 if !ok { 3685 return fmt.Errorf("expected ContactType to be of type string, got %T instead", value) 3686 } 3687 sv.ContactType = types.ContactType(jtv) 3688 } 3689 3690 case "CountryCode": 3691 if value != nil { 3692 jtv, ok := value.(string) 3693 if !ok { 3694 return fmt.Errorf("expected CountryCode to be of type string, got %T instead", value) 3695 } 3696 sv.CountryCode = types.CountryCode(jtv) 3697 } 3698 3699 case "Email": 3700 if value != nil { 3701 jtv, ok := value.(string) 3702 if !ok { 3703 return fmt.Errorf("expected Email to be of type string, got %T instead", value) 3704 } 3705 sv.Email = ptr.String(jtv) 3706 } 3707 3708 case "ExtraParams": 3709 if err := awsAwsjson11_deserializeDocumentExtraParamList(&sv.ExtraParams, value); err != nil { 3710 return err 3711 } 3712 3713 case "Fax": 3714 if value != nil { 3715 jtv, ok := value.(string) 3716 if !ok { 3717 return fmt.Errorf("expected ContactNumber to be of type string, got %T instead", value) 3718 } 3719 sv.Fax = ptr.String(jtv) 3720 } 3721 3722 case "FirstName": 3723 if value != nil { 3724 jtv, ok := value.(string) 3725 if !ok { 3726 return fmt.Errorf("expected ContactName to be of type string, got %T instead", value) 3727 } 3728 sv.FirstName = ptr.String(jtv) 3729 } 3730 3731 case "LastName": 3732 if value != nil { 3733 jtv, ok := value.(string) 3734 if !ok { 3735 return fmt.Errorf("expected ContactName to be of type string, got %T instead", value) 3736 } 3737 sv.LastName = ptr.String(jtv) 3738 } 3739 3740 case "OrganizationName": 3741 if value != nil { 3742 jtv, ok := value.(string) 3743 if !ok { 3744 return fmt.Errorf("expected ContactName to be of type string, got %T instead", value) 3745 } 3746 sv.OrganizationName = ptr.String(jtv) 3747 } 3748 3749 case "PhoneNumber": 3750 if value != nil { 3751 jtv, ok := value.(string) 3752 if !ok { 3753 return fmt.Errorf("expected ContactNumber to be of type string, got %T instead", value) 3754 } 3755 sv.PhoneNumber = ptr.String(jtv) 3756 } 3757 3758 case "State": 3759 if value != nil { 3760 jtv, ok := value.(string) 3761 if !ok { 3762 return fmt.Errorf("expected State to be of type string, got %T instead", value) 3763 } 3764 sv.State = ptr.String(jtv) 3765 } 3766 3767 case "ZipCode": 3768 if value != nil { 3769 jtv, ok := value.(string) 3770 if !ok { 3771 return fmt.Errorf("expected ZipCode to be of type string, got %T instead", value) 3772 } 3773 sv.ZipCode = ptr.String(jtv) 3774 } 3775 3776 default: 3777 _, _ = key, value 3778 3779 } 3780 } 3781 *v = sv 3782 return nil 3783} 3784 3785func awsAwsjson11_deserializeDocumentDomainLimitExceeded(v **types.DomainLimitExceeded, value interface{}) error { 3786 if v == nil { 3787 return fmt.Errorf("unexpected nil of type %T", v) 3788 } 3789 if value == nil { 3790 return nil 3791 } 3792 3793 shape, ok := value.(map[string]interface{}) 3794 if !ok { 3795 return fmt.Errorf("unexpected JSON type %v", value) 3796 } 3797 3798 var sv *types.DomainLimitExceeded 3799 if *v == nil { 3800 sv = &types.DomainLimitExceeded{} 3801 } else { 3802 sv = *v 3803 } 3804 3805 for key, value := range shape { 3806 switch key { 3807 case "message": 3808 if value != nil { 3809 jtv, ok := value.(string) 3810 if !ok { 3811 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 3812 } 3813 sv.Message = ptr.String(jtv) 3814 } 3815 3816 default: 3817 _, _ = key, value 3818 3819 } 3820 } 3821 *v = sv 3822 return nil 3823} 3824 3825func awsAwsjson11_deserializeDocumentDomainStatusList(v *[]string, value interface{}) error { 3826 if v == nil { 3827 return fmt.Errorf("unexpected nil of type %T", v) 3828 } 3829 if value == nil { 3830 return nil 3831 } 3832 3833 shape, ok := value.([]interface{}) 3834 if !ok { 3835 return fmt.Errorf("unexpected JSON type %v", value) 3836 } 3837 3838 var cv []string 3839 if *v == nil { 3840 cv = []string{} 3841 } else { 3842 cv = *v 3843 } 3844 3845 for _, value := range shape { 3846 var col string 3847 if value != nil { 3848 jtv, ok := value.(string) 3849 if !ok { 3850 return fmt.Errorf("expected DomainStatus to be of type string, got %T instead", value) 3851 } 3852 col = jtv 3853 } 3854 cv = append(cv, col) 3855 3856 } 3857 *v = cv 3858 return nil 3859} 3860 3861func awsAwsjson11_deserializeDocumentDomainSuggestion(v **types.DomainSuggestion, value interface{}) error { 3862 if v == nil { 3863 return fmt.Errorf("unexpected nil of type %T", v) 3864 } 3865 if value == nil { 3866 return nil 3867 } 3868 3869 shape, ok := value.(map[string]interface{}) 3870 if !ok { 3871 return fmt.Errorf("unexpected JSON type %v", value) 3872 } 3873 3874 var sv *types.DomainSuggestion 3875 if *v == nil { 3876 sv = &types.DomainSuggestion{} 3877 } else { 3878 sv = *v 3879 } 3880 3881 for key, value := range shape { 3882 switch key { 3883 case "Availability": 3884 if value != nil { 3885 jtv, ok := value.(string) 3886 if !ok { 3887 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3888 } 3889 sv.Availability = ptr.String(jtv) 3890 } 3891 3892 case "DomainName": 3893 if value != nil { 3894 jtv, ok := value.(string) 3895 if !ok { 3896 return fmt.Errorf("expected DomainName to be of type string, got %T instead", value) 3897 } 3898 sv.DomainName = ptr.String(jtv) 3899 } 3900 3901 default: 3902 _, _ = key, value 3903 3904 } 3905 } 3906 *v = sv 3907 return nil 3908} 3909 3910func awsAwsjson11_deserializeDocumentDomainSuggestionsList(v *[]types.DomainSuggestion, value interface{}) error { 3911 if v == nil { 3912 return fmt.Errorf("unexpected nil of type %T", v) 3913 } 3914 if value == nil { 3915 return nil 3916 } 3917 3918 shape, ok := value.([]interface{}) 3919 if !ok { 3920 return fmt.Errorf("unexpected JSON type %v", value) 3921 } 3922 3923 var cv []types.DomainSuggestion 3924 if *v == nil { 3925 cv = []types.DomainSuggestion{} 3926 } else { 3927 cv = *v 3928 } 3929 3930 for _, value := range shape { 3931 var col types.DomainSuggestion 3932 destAddr := &col 3933 if err := awsAwsjson11_deserializeDocumentDomainSuggestion(&destAddr, value); err != nil { 3934 return err 3935 } 3936 col = *destAddr 3937 cv = append(cv, col) 3938 3939 } 3940 *v = cv 3941 return nil 3942} 3943 3944func awsAwsjson11_deserializeDocumentDomainSummary(v **types.DomainSummary, value interface{}) error { 3945 if v == nil { 3946 return fmt.Errorf("unexpected nil of type %T", v) 3947 } 3948 if value == nil { 3949 return nil 3950 } 3951 3952 shape, ok := value.(map[string]interface{}) 3953 if !ok { 3954 return fmt.Errorf("unexpected JSON type %v", value) 3955 } 3956 3957 var sv *types.DomainSummary 3958 if *v == nil { 3959 sv = &types.DomainSummary{} 3960 } else { 3961 sv = *v 3962 } 3963 3964 for key, value := range shape { 3965 switch key { 3966 case "AutoRenew": 3967 if value != nil { 3968 jtv, ok := value.(bool) 3969 if !ok { 3970 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 3971 } 3972 sv.AutoRenew = ptr.Bool(jtv) 3973 } 3974 3975 case "DomainName": 3976 if value != nil { 3977 jtv, ok := value.(string) 3978 if !ok { 3979 return fmt.Errorf("expected DomainName to be of type string, got %T instead", value) 3980 } 3981 sv.DomainName = ptr.String(jtv) 3982 } 3983 3984 case "Expiry": 3985 if value != nil { 3986 jtv, ok := value.(json.Number) 3987 if !ok { 3988 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 3989 } 3990 f64, err := jtv.Float64() 3991 if err != nil { 3992 return err 3993 } 3994 sv.Expiry = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3995 } 3996 3997 case "TransferLock": 3998 if value != nil { 3999 jtv, ok := value.(bool) 4000 if !ok { 4001 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 4002 } 4003 sv.TransferLock = ptr.Bool(jtv) 4004 } 4005 4006 default: 4007 _, _ = key, value 4008 4009 } 4010 } 4011 *v = sv 4012 return nil 4013} 4014 4015func awsAwsjson11_deserializeDocumentDomainSummaryList(v *[]types.DomainSummary, value interface{}) error { 4016 if v == nil { 4017 return fmt.Errorf("unexpected nil of type %T", v) 4018 } 4019 if value == nil { 4020 return nil 4021 } 4022 4023 shape, ok := value.([]interface{}) 4024 if !ok { 4025 return fmt.Errorf("unexpected JSON type %v", value) 4026 } 4027 4028 var cv []types.DomainSummary 4029 if *v == nil { 4030 cv = []types.DomainSummary{} 4031 } else { 4032 cv = *v 4033 } 4034 4035 for _, value := range shape { 4036 var col types.DomainSummary 4037 destAddr := &col 4038 if err := awsAwsjson11_deserializeDocumentDomainSummary(&destAddr, value); err != nil { 4039 return err 4040 } 4041 col = *destAddr 4042 cv = append(cv, col) 4043 4044 } 4045 *v = cv 4046 return nil 4047} 4048 4049func awsAwsjson11_deserializeDocumentDomainTransferability(v **types.DomainTransferability, value interface{}) error { 4050 if v == nil { 4051 return fmt.Errorf("unexpected nil of type %T", v) 4052 } 4053 if value == nil { 4054 return nil 4055 } 4056 4057 shape, ok := value.(map[string]interface{}) 4058 if !ok { 4059 return fmt.Errorf("unexpected JSON type %v", value) 4060 } 4061 4062 var sv *types.DomainTransferability 4063 if *v == nil { 4064 sv = &types.DomainTransferability{} 4065 } else { 4066 sv = *v 4067 } 4068 4069 for key, value := range shape { 4070 switch key { 4071 case "Transferable": 4072 if value != nil { 4073 jtv, ok := value.(string) 4074 if !ok { 4075 return fmt.Errorf("expected Transferable to be of type string, got %T instead", value) 4076 } 4077 sv.Transferable = types.Transferable(jtv) 4078 } 4079 4080 default: 4081 _, _ = key, value 4082 4083 } 4084 } 4085 *v = sv 4086 return nil 4087} 4088 4089func awsAwsjson11_deserializeDocumentDuplicateRequest(v **types.DuplicateRequest, value interface{}) error { 4090 if v == nil { 4091 return fmt.Errorf("unexpected nil of type %T", v) 4092 } 4093 if value == nil { 4094 return nil 4095 } 4096 4097 shape, ok := value.(map[string]interface{}) 4098 if !ok { 4099 return fmt.Errorf("unexpected JSON type %v", value) 4100 } 4101 4102 var sv *types.DuplicateRequest 4103 if *v == nil { 4104 sv = &types.DuplicateRequest{} 4105 } else { 4106 sv = *v 4107 } 4108 4109 for key, value := range shape { 4110 switch key { 4111 case "message": 4112 if value != nil { 4113 jtv, ok := value.(string) 4114 if !ok { 4115 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 4116 } 4117 sv.Message = ptr.String(jtv) 4118 } 4119 4120 default: 4121 _, _ = key, value 4122 4123 } 4124 } 4125 *v = sv 4126 return nil 4127} 4128 4129func awsAwsjson11_deserializeDocumentExtraParam(v **types.ExtraParam, value interface{}) error { 4130 if v == nil { 4131 return fmt.Errorf("unexpected nil of type %T", v) 4132 } 4133 if value == nil { 4134 return nil 4135 } 4136 4137 shape, ok := value.(map[string]interface{}) 4138 if !ok { 4139 return fmt.Errorf("unexpected JSON type %v", value) 4140 } 4141 4142 var sv *types.ExtraParam 4143 if *v == nil { 4144 sv = &types.ExtraParam{} 4145 } else { 4146 sv = *v 4147 } 4148 4149 for key, value := range shape { 4150 switch key { 4151 case "Name": 4152 if value != nil { 4153 jtv, ok := value.(string) 4154 if !ok { 4155 return fmt.Errorf("expected ExtraParamName to be of type string, got %T instead", value) 4156 } 4157 sv.Name = types.ExtraParamName(jtv) 4158 } 4159 4160 case "Value": 4161 if value != nil { 4162 jtv, ok := value.(string) 4163 if !ok { 4164 return fmt.Errorf("expected ExtraParamValue to be of type string, got %T instead", value) 4165 } 4166 sv.Value = ptr.String(jtv) 4167 } 4168 4169 default: 4170 _, _ = key, value 4171 4172 } 4173 } 4174 *v = sv 4175 return nil 4176} 4177 4178func awsAwsjson11_deserializeDocumentExtraParamList(v *[]types.ExtraParam, value interface{}) error { 4179 if v == nil { 4180 return fmt.Errorf("unexpected nil of type %T", v) 4181 } 4182 if value == nil { 4183 return nil 4184 } 4185 4186 shape, ok := value.([]interface{}) 4187 if !ok { 4188 return fmt.Errorf("unexpected JSON type %v", value) 4189 } 4190 4191 var cv []types.ExtraParam 4192 if *v == nil { 4193 cv = []types.ExtraParam{} 4194 } else { 4195 cv = *v 4196 } 4197 4198 for _, value := range shape { 4199 var col types.ExtraParam 4200 destAddr := &col 4201 if err := awsAwsjson11_deserializeDocumentExtraParam(&destAddr, value); err != nil { 4202 return err 4203 } 4204 col = *destAddr 4205 cv = append(cv, col) 4206 4207 } 4208 *v = cv 4209 return nil 4210} 4211 4212func awsAwsjson11_deserializeDocumentGlueIpList(v *[]string, value interface{}) error { 4213 if v == nil { 4214 return fmt.Errorf("unexpected nil of type %T", v) 4215 } 4216 if value == nil { 4217 return nil 4218 } 4219 4220 shape, ok := value.([]interface{}) 4221 if !ok { 4222 return fmt.Errorf("unexpected JSON type %v", value) 4223 } 4224 4225 var cv []string 4226 if *v == nil { 4227 cv = []string{} 4228 } else { 4229 cv = *v 4230 } 4231 4232 for _, value := range shape { 4233 var col string 4234 if value != nil { 4235 jtv, ok := value.(string) 4236 if !ok { 4237 return fmt.Errorf("expected GlueIp to be of type string, got %T instead", value) 4238 } 4239 col = jtv 4240 } 4241 cv = append(cv, col) 4242 4243 } 4244 *v = cv 4245 return nil 4246} 4247 4248func awsAwsjson11_deserializeDocumentInvalidInput(v **types.InvalidInput, value interface{}) error { 4249 if v == nil { 4250 return fmt.Errorf("unexpected nil of type %T", v) 4251 } 4252 if value == nil { 4253 return nil 4254 } 4255 4256 shape, ok := value.(map[string]interface{}) 4257 if !ok { 4258 return fmt.Errorf("unexpected JSON type %v", value) 4259 } 4260 4261 var sv *types.InvalidInput 4262 if *v == nil { 4263 sv = &types.InvalidInput{} 4264 } else { 4265 sv = *v 4266 } 4267 4268 for key, value := range shape { 4269 switch key { 4270 case "message": 4271 if value != nil { 4272 jtv, ok := value.(string) 4273 if !ok { 4274 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 4275 } 4276 sv.Message = ptr.String(jtv) 4277 } 4278 4279 default: 4280 _, _ = key, value 4281 4282 } 4283 } 4284 *v = sv 4285 return nil 4286} 4287 4288func awsAwsjson11_deserializeDocumentNameserver(v **types.Nameserver, value interface{}) error { 4289 if v == nil { 4290 return fmt.Errorf("unexpected nil of type %T", v) 4291 } 4292 if value == nil { 4293 return nil 4294 } 4295 4296 shape, ok := value.(map[string]interface{}) 4297 if !ok { 4298 return fmt.Errorf("unexpected JSON type %v", value) 4299 } 4300 4301 var sv *types.Nameserver 4302 if *v == nil { 4303 sv = &types.Nameserver{} 4304 } else { 4305 sv = *v 4306 } 4307 4308 for key, value := range shape { 4309 switch key { 4310 case "GlueIps": 4311 if err := awsAwsjson11_deserializeDocumentGlueIpList(&sv.GlueIps, value); err != nil { 4312 return err 4313 } 4314 4315 case "Name": 4316 if value != nil { 4317 jtv, ok := value.(string) 4318 if !ok { 4319 return fmt.Errorf("expected HostName to be of type string, got %T instead", value) 4320 } 4321 sv.Name = ptr.String(jtv) 4322 } 4323 4324 default: 4325 _, _ = key, value 4326 4327 } 4328 } 4329 *v = sv 4330 return nil 4331} 4332 4333func awsAwsjson11_deserializeDocumentNameserverList(v *[]types.Nameserver, value interface{}) error { 4334 if v == nil { 4335 return fmt.Errorf("unexpected nil of type %T", v) 4336 } 4337 if value == nil { 4338 return nil 4339 } 4340 4341 shape, ok := value.([]interface{}) 4342 if !ok { 4343 return fmt.Errorf("unexpected JSON type %v", value) 4344 } 4345 4346 var cv []types.Nameserver 4347 if *v == nil { 4348 cv = []types.Nameserver{} 4349 } else { 4350 cv = *v 4351 } 4352 4353 for _, value := range shape { 4354 var col types.Nameserver 4355 destAddr := &col 4356 if err := awsAwsjson11_deserializeDocumentNameserver(&destAddr, value); err != nil { 4357 return err 4358 } 4359 col = *destAddr 4360 cv = append(cv, col) 4361 4362 } 4363 *v = cv 4364 return nil 4365} 4366 4367func awsAwsjson11_deserializeDocumentOperationLimitExceeded(v **types.OperationLimitExceeded, value interface{}) error { 4368 if v == nil { 4369 return fmt.Errorf("unexpected nil of type %T", v) 4370 } 4371 if value == nil { 4372 return nil 4373 } 4374 4375 shape, ok := value.(map[string]interface{}) 4376 if !ok { 4377 return fmt.Errorf("unexpected JSON type %v", value) 4378 } 4379 4380 var sv *types.OperationLimitExceeded 4381 if *v == nil { 4382 sv = &types.OperationLimitExceeded{} 4383 } else { 4384 sv = *v 4385 } 4386 4387 for key, value := range shape { 4388 switch key { 4389 case "message": 4390 if value != nil { 4391 jtv, ok := value.(string) 4392 if !ok { 4393 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 4394 } 4395 sv.Message = ptr.String(jtv) 4396 } 4397 4398 default: 4399 _, _ = key, value 4400 4401 } 4402 } 4403 *v = sv 4404 return nil 4405} 4406 4407func awsAwsjson11_deserializeDocumentOperationSummary(v **types.OperationSummary, value interface{}) error { 4408 if v == nil { 4409 return fmt.Errorf("unexpected nil of type %T", v) 4410 } 4411 if value == nil { 4412 return nil 4413 } 4414 4415 shape, ok := value.(map[string]interface{}) 4416 if !ok { 4417 return fmt.Errorf("unexpected JSON type %v", value) 4418 } 4419 4420 var sv *types.OperationSummary 4421 if *v == nil { 4422 sv = &types.OperationSummary{} 4423 } else { 4424 sv = *v 4425 } 4426 4427 for key, value := range shape { 4428 switch key { 4429 case "OperationId": 4430 if value != nil { 4431 jtv, ok := value.(string) 4432 if !ok { 4433 return fmt.Errorf("expected OperationId to be of type string, got %T instead", value) 4434 } 4435 sv.OperationId = ptr.String(jtv) 4436 } 4437 4438 case "Status": 4439 if value != nil { 4440 jtv, ok := value.(string) 4441 if !ok { 4442 return fmt.Errorf("expected OperationStatus to be of type string, got %T instead", value) 4443 } 4444 sv.Status = types.OperationStatus(jtv) 4445 } 4446 4447 case "SubmittedDate": 4448 if value != nil { 4449 jtv, ok := value.(json.Number) 4450 if !ok { 4451 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4452 } 4453 f64, err := jtv.Float64() 4454 if err != nil { 4455 return err 4456 } 4457 sv.SubmittedDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4458 } 4459 4460 case "Type": 4461 if value != nil { 4462 jtv, ok := value.(string) 4463 if !ok { 4464 return fmt.Errorf("expected OperationType to be of type string, got %T instead", value) 4465 } 4466 sv.Type = types.OperationType(jtv) 4467 } 4468 4469 default: 4470 _, _ = key, value 4471 4472 } 4473 } 4474 *v = sv 4475 return nil 4476} 4477 4478func awsAwsjson11_deserializeDocumentOperationSummaryList(v *[]types.OperationSummary, value interface{}) error { 4479 if v == nil { 4480 return fmt.Errorf("unexpected nil of type %T", v) 4481 } 4482 if value == nil { 4483 return nil 4484 } 4485 4486 shape, ok := value.([]interface{}) 4487 if !ok { 4488 return fmt.Errorf("unexpected JSON type %v", value) 4489 } 4490 4491 var cv []types.OperationSummary 4492 if *v == nil { 4493 cv = []types.OperationSummary{} 4494 } else { 4495 cv = *v 4496 } 4497 4498 for _, value := range shape { 4499 var col types.OperationSummary 4500 destAddr := &col 4501 if err := awsAwsjson11_deserializeDocumentOperationSummary(&destAddr, value); err != nil { 4502 return err 4503 } 4504 col = *destAddr 4505 cv = append(cv, col) 4506 4507 } 4508 *v = cv 4509 return nil 4510} 4511 4512func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 4513 if v == nil { 4514 return fmt.Errorf("unexpected nil of type %T", v) 4515 } 4516 if value == nil { 4517 return nil 4518 } 4519 4520 shape, ok := value.(map[string]interface{}) 4521 if !ok { 4522 return fmt.Errorf("unexpected JSON type %v", value) 4523 } 4524 4525 var sv *types.Tag 4526 if *v == nil { 4527 sv = &types.Tag{} 4528 } else { 4529 sv = *v 4530 } 4531 4532 for key, value := range shape { 4533 switch key { 4534 case "Key": 4535 if value != nil { 4536 jtv, ok := value.(string) 4537 if !ok { 4538 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 4539 } 4540 sv.Key = ptr.String(jtv) 4541 } 4542 4543 case "Value": 4544 if value != nil { 4545 jtv, ok := value.(string) 4546 if !ok { 4547 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 4548 } 4549 sv.Value = ptr.String(jtv) 4550 } 4551 4552 default: 4553 _, _ = key, value 4554 4555 } 4556 } 4557 *v = sv 4558 return nil 4559} 4560 4561func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error { 4562 if v == nil { 4563 return fmt.Errorf("unexpected nil of type %T", v) 4564 } 4565 if value == nil { 4566 return nil 4567 } 4568 4569 shape, ok := value.([]interface{}) 4570 if !ok { 4571 return fmt.Errorf("unexpected JSON type %v", value) 4572 } 4573 4574 var cv []types.Tag 4575 if *v == nil { 4576 cv = []types.Tag{} 4577 } else { 4578 cv = *v 4579 } 4580 4581 for _, value := range shape { 4582 var col types.Tag 4583 destAddr := &col 4584 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 4585 return err 4586 } 4587 col = *destAddr 4588 cv = append(cv, col) 4589 4590 } 4591 *v = cv 4592 return nil 4593} 4594 4595func awsAwsjson11_deserializeDocumentTLDRulesViolation(v **types.TLDRulesViolation, value interface{}) error { 4596 if v == nil { 4597 return fmt.Errorf("unexpected nil of type %T", v) 4598 } 4599 if value == nil { 4600 return nil 4601 } 4602 4603 shape, ok := value.(map[string]interface{}) 4604 if !ok { 4605 return fmt.Errorf("unexpected JSON type %v", value) 4606 } 4607 4608 var sv *types.TLDRulesViolation 4609 if *v == nil { 4610 sv = &types.TLDRulesViolation{} 4611 } else { 4612 sv = *v 4613 } 4614 4615 for key, value := range shape { 4616 switch key { 4617 case "message": 4618 if value != nil { 4619 jtv, ok := value.(string) 4620 if !ok { 4621 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 4622 } 4623 sv.Message = ptr.String(jtv) 4624 } 4625 4626 default: 4627 _, _ = key, value 4628 4629 } 4630 } 4631 *v = sv 4632 return nil 4633} 4634 4635func awsAwsjson11_deserializeDocumentUnsupportedTLD(v **types.UnsupportedTLD, value interface{}) error { 4636 if v == nil { 4637 return fmt.Errorf("unexpected nil of type %T", v) 4638 } 4639 if value == nil { 4640 return nil 4641 } 4642 4643 shape, ok := value.(map[string]interface{}) 4644 if !ok { 4645 return fmt.Errorf("unexpected JSON type %v", value) 4646 } 4647 4648 var sv *types.UnsupportedTLD 4649 if *v == nil { 4650 sv = &types.UnsupportedTLD{} 4651 } else { 4652 sv = *v 4653 } 4654 4655 for key, value := range shape { 4656 switch key { 4657 case "message": 4658 if value != nil { 4659 jtv, ok := value.(string) 4660 if !ok { 4661 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 4662 } 4663 sv.Message = ptr.String(jtv) 4664 } 4665 4666 default: 4667 _, _ = key, value 4668 4669 } 4670 } 4671 *v = sv 4672 return nil 4673} 4674 4675func awsAwsjson11_deserializeOpDocumentAcceptDomainTransferFromAnotherAwsAccountOutput(v **AcceptDomainTransferFromAnotherAwsAccountOutput, value interface{}) error { 4676 if v == nil { 4677 return fmt.Errorf("unexpected nil of type %T", v) 4678 } 4679 if value == nil { 4680 return nil 4681 } 4682 4683 shape, ok := value.(map[string]interface{}) 4684 if !ok { 4685 return fmt.Errorf("unexpected JSON type %v", value) 4686 } 4687 4688 var sv *AcceptDomainTransferFromAnotherAwsAccountOutput 4689 if *v == nil { 4690 sv = &AcceptDomainTransferFromAnotherAwsAccountOutput{} 4691 } else { 4692 sv = *v 4693 } 4694 4695 for key, value := range shape { 4696 switch key { 4697 case "OperationId": 4698 if value != nil { 4699 jtv, ok := value.(string) 4700 if !ok { 4701 return fmt.Errorf("expected OperationId to be of type string, got %T instead", value) 4702 } 4703 sv.OperationId = ptr.String(jtv) 4704 } 4705 4706 default: 4707 _, _ = key, value 4708 4709 } 4710 } 4711 *v = sv 4712 return nil 4713} 4714 4715func awsAwsjson11_deserializeOpDocumentCancelDomainTransferToAnotherAwsAccountOutput(v **CancelDomainTransferToAnotherAwsAccountOutput, value interface{}) error { 4716 if v == nil { 4717 return fmt.Errorf("unexpected nil of type %T", v) 4718 } 4719 if value == nil { 4720 return nil 4721 } 4722 4723 shape, ok := value.(map[string]interface{}) 4724 if !ok { 4725 return fmt.Errorf("unexpected JSON type %v", value) 4726 } 4727 4728 var sv *CancelDomainTransferToAnotherAwsAccountOutput 4729 if *v == nil { 4730 sv = &CancelDomainTransferToAnotherAwsAccountOutput{} 4731 } else { 4732 sv = *v 4733 } 4734 4735 for key, value := range shape { 4736 switch key { 4737 case "OperationId": 4738 if value != nil { 4739 jtv, ok := value.(string) 4740 if !ok { 4741 return fmt.Errorf("expected OperationId to be of type string, got %T instead", value) 4742 } 4743 sv.OperationId = ptr.String(jtv) 4744 } 4745 4746 default: 4747 _, _ = key, value 4748 4749 } 4750 } 4751 *v = sv 4752 return nil 4753} 4754 4755func awsAwsjson11_deserializeOpDocumentCheckDomainAvailabilityOutput(v **CheckDomainAvailabilityOutput, value interface{}) error { 4756 if v == nil { 4757 return fmt.Errorf("unexpected nil of type %T", v) 4758 } 4759 if value == nil { 4760 return nil 4761 } 4762 4763 shape, ok := value.(map[string]interface{}) 4764 if !ok { 4765 return fmt.Errorf("unexpected JSON type %v", value) 4766 } 4767 4768 var sv *CheckDomainAvailabilityOutput 4769 if *v == nil { 4770 sv = &CheckDomainAvailabilityOutput{} 4771 } else { 4772 sv = *v 4773 } 4774 4775 for key, value := range shape { 4776 switch key { 4777 case "Availability": 4778 if value != nil { 4779 jtv, ok := value.(string) 4780 if !ok { 4781 return fmt.Errorf("expected DomainAvailability to be of type string, got %T instead", value) 4782 } 4783 sv.Availability = types.DomainAvailability(jtv) 4784 } 4785 4786 default: 4787 _, _ = key, value 4788 4789 } 4790 } 4791 *v = sv 4792 return nil 4793} 4794 4795func awsAwsjson11_deserializeOpDocumentCheckDomainTransferabilityOutput(v **CheckDomainTransferabilityOutput, value interface{}) error { 4796 if v == nil { 4797 return fmt.Errorf("unexpected nil of type %T", v) 4798 } 4799 if value == nil { 4800 return nil 4801 } 4802 4803 shape, ok := value.(map[string]interface{}) 4804 if !ok { 4805 return fmt.Errorf("unexpected JSON type %v", value) 4806 } 4807 4808 var sv *CheckDomainTransferabilityOutput 4809 if *v == nil { 4810 sv = &CheckDomainTransferabilityOutput{} 4811 } else { 4812 sv = *v 4813 } 4814 4815 for key, value := range shape { 4816 switch key { 4817 case "Transferability": 4818 if err := awsAwsjson11_deserializeDocumentDomainTransferability(&sv.Transferability, value); err != nil { 4819 return err 4820 } 4821 4822 default: 4823 _, _ = key, value 4824 4825 } 4826 } 4827 *v = sv 4828 return nil 4829} 4830 4831func awsAwsjson11_deserializeOpDocumentDeleteTagsForDomainOutput(v **DeleteTagsForDomainOutput, value interface{}) error { 4832 if v == nil { 4833 return fmt.Errorf("unexpected nil of type %T", v) 4834 } 4835 if value == nil { 4836 return nil 4837 } 4838 4839 shape, ok := value.(map[string]interface{}) 4840 if !ok { 4841 return fmt.Errorf("unexpected JSON type %v", value) 4842 } 4843 4844 var sv *DeleteTagsForDomainOutput 4845 if *v == nil { 4846 sv = &DeleteTagsForDomainOutput{} 4847 } else { 4848 sv = *v 4849 } 4850 4851 for key, value := range shape { 4852 switch key { 4853 default: 4854 _, _ = key, value 4855 4856 } 4857 } 4858 *v = sv 4859 return nil 4860} 4861 4862func awsAwsjson11_deserializeOpDocumentDisableDomainAutoRenewOutput(v **DisableDomainAutoRenewOutput, value interface{}) error { 4863 if v == nil { 4864 return fmt.Errorf("unexpected nil of type %T", v) 4865 } 4866 if value == nil { 4867 return nil 4868 } 4869 4870 shape, ok := value.(map[string]interface{}) 4871 if !ok { 4872 return fmt.Errorf("unexpected JSON type %v", value) 4873 } 4874 4875 var sv *DisableDomainAutoRenewOutput 4876 if *v == nil { 4877 sv = &DisableDomainAutoRenewOutput{} 4878 } else { 4879 sv = *v 4880 } 4881 4882 for key, value := range shape { 4883 switch key { 4884 default: 4885 _, _ = key, value 4886 4887 } 4888 } 4889 *v = sv 4890 return nil 4891} 4892 4893func awsAwsjson11_deserializeOpDocumentDisableDomainTransferLockOutput(v **DisableDomainTransferLockOutput, value interface{}) error { 4894 if v == nil { 4895 return fmt.Errorf("unexpected nil of type %T", v) 4896 } 4897 if value == nil { 4898 return nil 4899 } 4900 4901 shape, ok := value.(map[string]interface{}) 4902 if !ok { 4903 return fmt.Errorf("unexpected JSON type %v", value) 4904 } 4905 4906 var sv *DisableDomainTransferLockOutput 4907 if *v == nil { 4908 sv = &DisableDomainTransferLockOutput{} 4909 } else { 4910 sv = *v 4911 } 4912 4913 for key, value := range shape { 4914 switch key { 4915 case "OperationId": 4916 if value != nil { 4917 jtv, ok := value.(string) 4918 if !ok { 4919 return fmt.Errorf("expected OperationId to be of type string, got %T instead", value) 4920 } 4921 sv.OperationId = ptr.String(jtv) 4922 } 4923 4924 default: 4925 _, _ = key, value 4926 4927 } 4928 } 4929 *v = sv 4930 return nil 4931} 4932 4933func awsAwsjson11_deserializeOpDocumentEnableDomainAutoRenewOutput(v **EnableDomainAutoRenewOutput, value interface{}) error { 4934 if v == nil { 4935 return fmt.Errorf("unexpected nil of type %T", v) 4936 } 4937 if value == nil { 4938 return nil 4939 } 4940 4941 shape, ok := value.(map[string]interface{}) 4942 if !ok { 4943 return fmt.Errorf("unexpected JSON type %v", value) 4944 } 4945 4946 var sv *EnableDomainAutoRenewOutput 4947 if *v == nil { 4948 sv = &EnableDomainAutoRenewOutput{} 4949 } else { 4950 sv = *v 4951 } 4952 4953 for key, value := range shape { 4954 switch key { 4955 default: 4956 _, _ = key, value 4957 4958 } 4959 } 4960 *v = sv 4961 return nil 4962} 4963 4964func awsAwsjson11_deserializeOpDocumentEnableDomainTransferLockOutput(v **EnableDomainTransferLockOutput, value interface{}) error { 4965 if v == nil { 4966 return fmt.Errorf("unexpected nil of type %T", v) 4967 } 4968 if value == nil { 4969 return nil 4970 } 4971 4972 shape, ok := value.(map[string]interface{}) 4973 if !ok { 4974 return fmt.Errorf("unexpected JSON type %v", value) 4975 } 4976 4977 var sv *EnableDomainTransferLockOutput 4978 if *v == nil { 4979 sv = &EnableDomainTransferLockOutput{} 4980 } else { 4981 sv = *v 4982 } 4983 4984 for key, value := range shape { 4985 switch key { 4986 case "OperationId": 4987 if value != nil { 4988 jtv, ok := value.(string) 4989 if !ok { 4990 return fmt.Errorf("expected OperationId to be of type string, got %T instead", value) 4991 } 4992 sv.OperationId = ptr.String(jtv) 4993 } 4994 4995 default: 4996 _, _ = key, value 4997 4998 } 4999 } 5000 *v = sv 5001 return nil 5002} 5003 5004func awsAwsjson11_deserializeOpDocumentGetContactReachabilityStatusOutput(v **GetContactReachabilityStatusOutput, value interface{}) error { 5005 if v == nil { 5006 return fmt.Errorf("unexpected nil of type %T", v) 5007 } 5008 if value == nil { 5009 return nil 5010 } 5011 5012 shape, ok := value.(map[string]interface{}) 5013 if !ok { 5014 return fmt.Errorf("unexpected JSON type %v", value) 5015 } 5016 5017 var sv *GetContactReachabilityStatusOutput 5018 if *v == nil { 5019 sv = &GetContactReachabilityStatusOutput{} 5020 } else { 5021 sv = *v 5022 } 5023 5024 for key, value := range shape { 5025 switch key { 5026 case "domainName": 5027 if value != nil { 5028 jtv, ok := value.(string) 5029 if !ok { 5030 return fmt.Errorf("expected DomainName to be of type string, got %T instead", value) 5031 } 5032 sv.DomainName = ptr.String(jtv) 5033 } 5034 5035 case "status": 5036 if value != nil { 5037 jtv, ok := value.(string) 5038 if !ok { 5039 return fmt.Errorf("expected ReachabilityStatus to be of type string, got %T instead", value) 5040 } 5041 sv.Status = types.ReachabilityStatus(jtv) 5042 } 5043 5044 default: 5045 _, _ = key, value 5046 5047 } 5048 } 5049 *v = sv 5050 return nil 5051} 5052 5053func awsAwsjson11_deserializeOpDocumentGetDomainDetailOutput(v **GetDomainDetailOutput, value interface{}) error { 5054 if v == nil { 5055 return fmt.Errorf("unexpected nil of type %T", v) 5056 } 5057 if value == nil { 5058 return nil 5059 } 5060 5061 shape, ok := value.(map[string]interface{}) 5062 if !ok { 5063 return fmt.Errorf("unexpected JSON type %v", value) 5064 } 5065 5066 var sv *GetDomainDetailOutput 5067 if *v == nil { 5068 sv = &GetDomainDetailOutput{} 5069 } else { 5070 sv = *v 5071 } 5072 5073 for key, value := range shape { 5074 switch key { 5075 case "AbuseContactEmail": 5076 if value != nil { 5077 jtv, ok := value.(string) 5078 if !ok { 5079 return fmt.Errorf("expected Email to be of type string, got %T instead", value) 5080 } 5081 sv.AbuseContactEmail = ptr.String(jtv) 5082 } 5083 5084 case "AbuseContactPhone": 5085 if value != nil { 5086 jtv, ok := value.(string) 5087 if !ok { 5088 return fmt.Errorf("expected ContactNumber to be of type string, got %T instead", value) 5089 } 5090 sv.AbuseContactPhone = ptr.String(jtv) 5091 } 5092 5093 case "AdminContact": 5094 if err := awsAwsjson11_deserializeDocumentContactDetail(&sv.AdminContact, value); err != nil { 5095 return err 5096 } 5097 5098 case "AdminPrivacy": 5099 if value != nil { 5100 jtv, ok := value.(bool) 5101 if !ok { 5102 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5103 } 5104 sv.AdminPrivacy = ptr.Bool(jtv) 5105 } 5106 5107 case "AutoRenew": 5108 if value != nil { 5109 jtv, ok := value.(bool) 5110 if !ok { 5111 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5112 } 5113 sv.AutoRenew = ptr.Bool(jtv) 5114 } 5115 5116 case "CreationDate": 5117 if value != nil { 5118 jtv, ok := value.(json.Number) 5119 if !ok { 5120 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5121 } 5122 f64, err := jtv.Float64() 5123 if err != nil { 5124 return err 5125 } 5126 sv.CreationDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5127 } 5128 5129 case "DnsSec": 5130 if value != nil { 5131 jtv, ok := value.(string) 5132 if !ok { 5133 return fmt.Errorf("expected DNSSec to be of type string, got %T instead", value) 5134 } 5135 sv.DnsSec = ptr.String(jtv) 5136 } 5137 5138 case "DomainName": 5139 if value != nil { 5140 jtv, ok := value.(string) 5141 if !ok { 5142 return fmt.Errorf("expected DomainName to be of type string, got %T instead", value) 5143 } 5144 sv.DomainName = ptr.String(jtv) 5145 } 5146 5147 case "ExpirationDate": 5148 if value != nil { 5149 jtv, ok := value.(json.Number) 5150 if !ok { 5151 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5152 } 5153 f64, err := jtv.Float64() 5154 if err != nil { 5155 return err 5156 } 5157 sv.ExpirationDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5158 } 5159 5160 case "Nameservers": 5161 if err := awsAwsjson11_deserializeDocumentNameserverList(&sv.Nameservers, value); err != nil { 5162 return err 5163 } 5164 5165 case "RegistrantContact": 5166 if err := awsAwsjson11_deserializeDocumentContactDetail(&sv.RegistrantContact, value); err != nil { 5167 return err 5168 } 5169 5170 case "RegistrantPrivacy": 5171 if value != nil { 5172 jtv, ok := value.(bool) 5173 if !ok { 5174 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5175 } 5176 sv.RegistrantPrivacy = ptr.Bool(jtv) 5177 } 5178 5179 case "RegistrarName": 5180 if value != nil { 5181 jtv, ok := value.(string) 5182 if !ok { 5183 return fmt.Errorf("expected RegistrarName to be of type string, got %T instead", value) 5184 } 5185 sv.RegistrarName = ptr.String(jtv) 5186 } 5187 5188 case "RegistrarUrl": 5189 if value != nil { 5190 jtv, ok := value.(string) 5191 if !ok { 5192 return fmt.Errorf("expected RegistrarUrl to be of type string, got %T instead", value) 5193 } 5194 sv.RegistrarUrl = ptr.String(jtv) 5195 } 5196 5197 case "RegistryDomainId": 5198 if value != nil { 5199 jtv, ok := value.(string) 5200 if !ok { 5201 return fmt.Errorf("expected RegistryDomainId to be of type string, got %T instead", value) 5202 } 5203 sv.RegistryDomainId = ptr.String(jtv) 5204 } 5205 5206 case "Reseller": 5207 if value != nil { 5208 jtv, ok := value.(string) 5209 if !ok { 5210 return fmt.Errorf("expected Reseller to be of type string, got %T instead", value) 5211 } 5212 sv.Reseller = ptr.String(jtv) 5213 } 5214 5215 case "StatusList": 5216 if err := awsAwsjson11_deserializeDocumentDomainStatusList(&sv.StatusList, value); err != nil { 5217 return err 5218 } 5219 5220 case "TechContact": 5221 if err := awsAwsjson11_deserializeDocumentContactDetail(&sv.TechContact, value); err != nil { 5222 return err 5223 } 5224 5225 case "TechPrivacy": 5226 if value != nil { 5227 jtv, ok := value.(bool) 5228 if !ok { 5229 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5230 } 5231 sv.TechPrivacy = ptr.Bool(jtv) 5232 } 5233 5234 case "UpdatedDate": 5235 if value != nil { 5236 jtv, ok := value.(json.Number) 5237 if !ok { 5238 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5239 } 5240 f64, err := jtv.Float64() 5241 if err != nil { 5242 return err 5243 } 5244 sv.UpdatedDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5245 } 5246 5247 case "WhoIsServer": 5248 if value != nil { 5249 jtv, ok := value.(string) 5250 if !ok { 5251 return fmt.Errorf("expected RegistrarWhoIsServer to be of type string, got %T instead", value) 5252 } 5253 sv.WhoIsServer = ptr.String(jtv) 5254 } 5255 5256 default: 5257 _, _ = key, value 5258 5259 } 5260 } 5261 *v = sv 5262 return nil 5263} 5264 5265func awsAwsjson11_deserializeOpDocumentGetDomainSuggestionsOutput(v **GetDomainSuggestionsOutput, value interface{}) error { 5266 if v == nil { 5267 return fmt.Errorf("unexpected nil of type %T", v) 5268 } 5269 if value == nil { 5270 return nil 5271 } 5272 5273 shape, ok := value.(map[string]interface{}) 5274 if !ok { 5275 return fmt.Errorf("unexpected JSON type %v", value) 5276 } 5277 5278 var sv *GetDomainSuggestionsOutput 5279 if *v == nil { 5280 sv = &GetDomainSuggestionsOutput{} 5281 } else { 5282 sv = *v 5283 } 5284 5285 for key, value := range shape { 5286 switch key { 5287 case "SuggestionsList": 5288 if err := awsAwsjson11_deserializeDocumentDomainSuggestionsList(&sv.SuggestionsList, value); err != nil { 5289 return err 5290 } 5291 5292 default: 5293 _, _ = key, value 5294 5295 } 5296 } 5297 *v = sv 5298 return nil 5299} 5300 5301func awsAwsjson11_deserializeOpDocumentGetOperationDetailOutput(v **GetOperationDetailOutput, value interface{}) error { 5302 if v == nil { 5303 return fmt.Errorf("unexpected nil of type %T", v) 5304 } 5305 if value == nil { 5306 return nil 5307 } 5308 5309 shape, ok := value.(map[string]interface{}) 5310 if !ok { 5311 return fmt.Errorf("unexpected JSON type %v", value) 5312 } 5313 5314 var sv *GetOperationDetailOutput 5315 if *v == nil { 5316 sv = &GetOperationDetailOutput{} 5317 } else { 5318 sv = *v 5319 } 5320 5321 for key, value := range shape { 5322 switch key { 5323 case "DomainName": 5324 if value != nil { 5325 jtv, ok := value.(string) 5326 if !ok { 5327 return fmt.Errorf("expected DomainName to be of type string, got %T instead", value) 5328 } 5329 sv.DomainName = ptr.String(jtv) 5330 } 5331 5332 case "Message": 5333 if value != nil { 5334 jtv, ok := value.(string) 5335 if !ok { 5336 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5337 } 5338 sv.Message = ptr.String(jtv) 5339 } 5340 5341 case "OperationId": 5342 if value != nil { 5343 jtv, ok := value.(string) 5344 if !ok { 5345 return fmt.Errorf("expected OperationId to be of type string, got %T instead", value) 5346 } 5347 sv.OperationId = ptr.String(jtv) 5348 } 5349 5350 case "Status": 5351 if value != nil { 5352 jtv, ok := value.(string) 5353 if !ok { 5354 return fmt.Errorf("expected OperationStatus to be of type string, got %T instead", value) 5355 } 5356 sv.Status = types.OperationStatus(jtv) 5357 } 5358 5359 case "SubmittedDate": 5360 if value != nil { 5361 jtv, ok := value.(json.Number) 5362 if !ok { 5363 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5364 } 5365 f64, err := jtv.Float64() 5366 if err != nil { 5367 return err 5368 } 5369 sv.SubmittedDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5370 } 5371 5372 case "Type": 5373 if value != nil { 5374 jtv, ok := value.(string) 5375 if !ok { 5376 return fmt.Errorf("expected OperationType to be of type string, got %T instead", value) 5377 } 5378 sv.Type = types.OperationType(jtv) 5379 } 5380 5381 default: 5382 _, _ = key, value 5383 5384 } 5385 } 5386 *v = sv 5387 return nil 5388} 5389 5390func awsAwsjson11_deserializeOpDocumentListDomainsOutput(v **ListDomainsOutput, value interface{}) error { 5391 if v == nil { 5392 return fmt.Errorf("unexpected nil of type %T", v) 5393 } 5394 if value == nil { 5395 return nil 5396 } 5397 5398 shape, ok := value.(map[string]interface{}) 5399 if !ok { 5400 return fmt.Errorf("unexpected JSON type %v", value) 5401 } 5402 5403 var sv *ListDomainsOutput 5404 if *v == nil { 5405 sv = &ListDomainsOutput{} 5406 } else { 5407 sv = *v 5408 } 5409 5410 for key, value := range shape { 5411 switch key { 5412 case "Domains": 5413 if err := awsAwsjson11_deserializeDocumentDomainSummaryList(&sv.Domains, value); err != nil { 5414 return err 5415 } 5416 5417 case "NextPageMarker": 5418 if value != nil { 5419 jtv, ok := value.(string) 5420 if !ok { 5421 return fmt.Errorf("expected PageMarker to be of type string, got %T instead", value) 5422 } 5423 sv.NextPageMarker = ptr.String(jtv) 5424 } 5425 5426 default: 5427 _, _ = key, value 5428 5429 } 5430 } 5431 *v = sv 5432 return nil 5433} 5434 5435func awsAwsjson11_deserializeOpDocumentListOperationsOutput(v **ListOperationsOutput, value interface{}) error { 5436 if v == nil { 5437 return fmt.Errorf("unexpected nil of type %T", v) 5438 } 5439 if value == nil { 5440 return nil 5441 } 5442 5443 shape, ok := value.(map[string]interface{}) 5444 if !ok { 5445 return fmt.Errorf("unexpected JSON type %v", value) 5446 } 5447 5448 var sv *ListOperationsOutput 5449 if *v == nil { 5450 sv = &ListOperationsOutput{} 5451 } else { 5452 sv = *v 5453 } 5454 5455 for key, value := range shape { 5456 switch key { 5457 case "NextPageMarker": 5458 if value != nil { 5459 jtv, ok := value.(string) 5460 if !ok { 5461 return fmt.Errorf("expected PageMarker to be of type string, got %T instead", value) 5462 } 5463 sv.NextPageMarker = ptr.String(jtv) 5464 } 5465 5466 case "Operations": 5467 if err := awsAwsjson11_deserializeDocumentOperationSummaryList(&sv.Operations, value); err != nil { 5468 return err 5469 } 5470 5471 default: 5472 _, _ = key, value 5473 5474 } 5475 } 5476 *v = sv 5477 return nil 5478} 5479 5480func awsAwsjson11_deserializeOpDocumentListTagsForDomainOutput(v **ListTagsForDomainOutput, value interface{}) error { 5481 if v == nil { 5482 return fmt.Errorf("unexpected nil of type %T", v) 5483 } 5484 if value == nil { 5485 return nil 5486 } 5487 5488 shape, ok := value.(map[string]interface{}) 5489 if !ok { 5490 return fmt.Errorf("unexpected JSON type %v", value) 5491 } 5492 5493 var sv *ListTagsForDomainOutput 5494 if *v == nil { 5495 sv = &ListTagsForDomainOutput{} 5496 } else { 5497 sv = *v 5498 } 5499 5500 for key, value := range shape { 5501 switch key { 5502 case "TagList": 5503 if err := awsAwsjson11_deserializeDocumentTagList(&sv.TagList, value); err != nil { 5504 return err 5505 } 5506 5507 default: 5508 _, _ = key, value 5509 5510 } 5511 } 5512 *v = sv 5513 return nil 5514} 5515 5516func awsAwsjson11_deserializeOpDocumentRegisterDomainOutput(v **RegisterDomainOutput, value interface{}) error { 5517 if v == nil { 5518 return fmt.Errorf("unexpected nil of type %T", v) 5519 } 5520 if value == nil { 5521 return nil 5522 } 5523 5524 shape, ok := value.(map[string]interface{}) 5525 if !ok { 5526 return fmt.Errorf("unexpected JSON type %v", value) 5527 } 5528 5529 var sv *RegisterDomainOutput 5530 if *v == nil { 5531 sv = &RegisterDomainOutput{} 5532 } else { 5533 sv = *v 5534 } 5535 5536 for key, value := range shape { 5537 switch key { 5538 case "OperationId": 5539 if value != nil { 5540 jtv, ok := value.(string) 5541 if !ok { 5542 return fmt.Errorf("expected OperationId to be of type string, got %T instead", value) 5543 } 5544 sv.OperationId = ptr.String(jtv) 5545 } 5546 5547 default: 5548 _, _ = key, value 5549 5550 } 5551 } 5552 *v = sv 5553 return nil 5554} 5555 5556func awsAwsjson11_deserializeOpDocumentRejectDomainTransferFromAnotherAwsAccountOutput(v **RejectDomainTransferFromAnotherAwsAccountOutput, value interface{}) error { 5557 if v == nil { 5558 return fmt.Errorf("unexpected nil of type %T", v) 5559 } 5560 if value == nil { 5561 return nil 5562 } 5563 5564 shape, ok := value.(map[string]interface{}) 5565 if !ok { 5566 return fmt.Errorf("unexpected JSON type %v", value) 5567 } 5568 5569 var sv *RejectDomainTransferFromAnotherAwsAccountOutput 5570 if *v == nil { 5571 sv = &RejectDomainTransferFromAnotherAwsAccountOutput{} 5572 } else { 5573 sv = *v 5574 } 5575 5576 for key, value := range shape { 5577 switch key { 5578 case "OperationId": 5579 if value != nil { 5580 jtv, ok := value.(string) 5581 if !ok { 5582 return fmt.Errorf("expected OperationId to be of type string, got %T instead", value) 5583 } 5584 sv.OperationId = ptr.String(jtv) 5585 } 5586 5587 default: 5588 _, _ = key, value 5589 5590 } 5591 } 5592 *v = sv 5593 return nil 5594} 5595 5596func awsAwsjson11_deserializeOpDocumentRenewDomainOutput(v **RenewDomainOutput, value interface{}) error { 5597 if v == nil { 5598 return fmt.Errorf("unexpected nil of type %T", v) 5599 } 5600 if value == nil { 5601 return nil 5602 } 5603 5604 shape, ok := value.(map[string]interface{}) 5605 if !ok { 5606 return fmt.Errorf("unexpected JSON type %v", value) 5607 } 5608 5609 var sv *RenewDomainOutput 5610 if *v == nil { 5611 sv = &RenewDomainOutput{} 5612 } else { 5613 sv = *v 5614 } 5615 5616 for key, value := range shape { 5617 switch key { 5618 case "OperationId": 5619 if value != nil { 5620 jtv, ok := value.(string) 5621 if !ok { 5622 return fmt.Errorf("expected OperationId to be of type string, got %T instead", value) 5623 } 5624 sv.OperationId = ptr.String(jtv) 5625 } 5626 5627 default: 5628 _, _ = key, value 5629 5630 } 5631 } 5632 *v = sv 5633 return nil 5634} 5635 5636func awsAwsjson11_deserializeOpDocumentResendContactReachabilityEmailOutput(v **ResendContactReachabilityEmailOutput, value interface{}) error { 5637 if v == nil { 5638 return fmt.Errorf("unexpected nil of type %T", v) 5639 } 5640 if value == nil { 5641 return nil 5642 } 5643 5644 shape, ok := value.(map[string]interface{}) 5645 if !ok { 5646 return fmt.Errorf("unexpected JSON type %v", value) 5647 } 5648 5649 var sv *ResendContactReachabilityEmailOutput 5650 if *v == nil { 5651 sv = &ResendContactReachabilityEmailOutput{} 5652 } else { 5653 sv = *v 5654 } 5655 5656 for key, value := range shape { 5657 switch key { 5658 case "domainName": 5659 if value != nil { 5660 jtv, ok := value.(string) 5661 if !ok { 5662 return fmt.Errorf("expected DomainName to be of type string, got %T instead", value) 5663 } 5664 sv.DomainName = ptr.String(jtv) 5665 } 5666 5667 case "emailAddress": 5668 if value != nil { 5669 jtv, ok := value.(string) 5670 if !ok { 5671 return fmt.Errorf("expected Email to be of type string, got %T instead", value) 5672 } 5673 sv.EmailAddress = ptr.String(jtv) 5674 } 5675 5676 case "isAlreadyVerified": 5677 if value != nil { 5678 jtv, ok := value.(bool) 5679 if !ok { 5680 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5681 } 5682 sv.IsAlreadyVerified = ptr.Bool(jtv) 5683 } 5684 5685 default: 5686 _, _ = key, value 5687 5688 } 5689 } 5690 *v = sv 5691 return nil 5692} 5693 5694func awsAwsjson11_deserializeOpDocumentRetrieveDomainAuthCodeOutput(v **RetrieveDomainAuthCodeOutput, value interface{}) error { 5695 if v == nil { 5696 return fmt.Errorf("unexpected nil of type %T", v) 5697 } 5698 if value == nil { 5699 return nil 5700 } 5701 5702 shape, ok := value.(map[string]interface{}) 5703 if !ok { 5704 return fmt.Errorf("unexpected JSON type %v", value) 5705 } 5706 5707 var sv *RetrieveDomainAuthCodeOutput 5708 if *v == nil { 5709 sv = &RetrieveDomainAuthCodeOutput{} 5710 } else { 5711 sv = *v 5712 } 5713 5714 for key, value := range shape { 5715 switch key { 5716 case "AuthCode": 5717 if value != nil { 5718 jtv, ok := value.(string) 5719 if !ok { 5720 return fmt.Errorf("expected DomainAuthCode to be of type string, got %T instead", value) 5721 } 5722 sv.AuthCode = ptr.String(jtv) 5723 } 5724 5725 default: 5726 _, _ = key, value 5727 5728 } 5729 } 5730 *v = sv 5731 return nil 5732} 5733 5734func awsAwsjson11_deserializeOpDocumentTransferDomainOutput(v **TransferDomainOutput, value interface{}) error { 5735 if v == nil { 5736 return fmt.Errorf("unexpected nil of type %T", v) 5737 } 5738 if value == nil { 5739 return nil 5740 } 5741 5742 shape, ok := value.(map[string]interface{}) 5743 if !ok { 5744 return fmt.Errorf("unexpected JSON type %v", value) 5745 } 5746 5747 var sv *TransferDomainOutput 5748 if *v == nil { 5749 sv = &TransferDomainOutput{} 5750 } else { 5751 sv = *v 5752 } 5753 5754 for key, value := range shape { 5755 switch key { 5756 case "OperationId": 5757 if value != nil { 5758 jtv, ok := value.(string) 5759 if !ok { 5760 return fmt.Errorf("expected OperationId to be of type string, got %T instead", value) 5761 } 5762 sv.OperationId = ptr.String(jtv) 5763 } 5764 5765 default: 5766 _, _ = key, value 5767 5768 } 5769 } 5770 *v = sv 5771 return nil 5772} 5773 5774func awsAwsjson11_deserializeOpDocumentTransferDomainToAnotherAwsAccountOutput(v **TransferDomainToAnotherAwsAccountOutput, value interface{}) error { 5775 if v == nil { 5776 return fmt.Errorf("unexpected nil of type %T", v) 5777 } 5778 if value == nil { 5779 return nil 5780 } 5781 5782 shape, ok := value.(map[string]interface{}) 5783 if !ok { 5784 return fmt.Errorf("unexpected JSON type %v", value) 5785 } 5786 5787 var sv *TransferDomainToAnotherAwsAccountOutput 5788 if *v == nil { 5789 sv = &TransferDomainToAnotherAwsAccountOutput{} 5790 } else { 5791 sv = *v 5792 } 5793 5794 for key, value := range shape { 5795 switch key { 5796 case "OperationId": 5797 if value != nil { 5798 jtv, ok := value.(string) 5799 if !ok { 5800 return fmt.Errorf("expected OperationId to be of type string, got %T instead", value) 5801 } 5802 sv.OperationId = ptr.String(jtv) 5803 } 5804 5805 case "Password": 5806 if value != nil { 5807 jtv, ok := value.(string) 5808 if !ok { 5809 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5810 } 5811 sv.Password = ptr.String(jtv) 5812 } 5813 5814 default: 5815 _, _ = key, value 5816 5817 } 5818 } 5819 *v = sv 5820 return nil 5821} 5822 5823func awsAwsjson11_deserializeOpDocumentUpdateDomainContactOutput(v **UpdateDomainContactOutput, value interface{}) error { 5824 if v == nil { 5825 return fmt.Errorf("unexpected nil of type %T", v) 5826 } 5827 if value == nil { 5828 return nil 5829 } 5830 5831 shape, ok := value.(map[string]interface{}) 5832 if !ok { 5833 return fmt.Errorf("unexpected JSON type %v", value) 5834 } 5835 5836 var sv *UpdateDomainContactOutput 5837 if *v == nil { 5838 sv = &UpdateDomainContactOutput{} 5839 } else { 5840 sv = *v 5841 } 5842 5843 for key, value := range shape { 5844 switch key { 5845 case "OperationId": 5846 if value != nil { 5847 jtv, ok := value.(string) 5848 if !ok { 5849 return fmt.Errorf("expected OperationId to be of type string, got %T instead", value) 5850 } 5851 sv.OperationId = ptr.String(jtv) 5852 } 5853 5854 default: 5855 _, _ = key, value 5856 5857 } 5858 } 5859 *v = sv 5860 return nil 5861} 5862 5863func awsAwsjson11_deserializeOpDocumentUpdateDomainContactPrivacyOutput(v **UpdateDomainContactPrivacyOutput, value interface{}) error { 5864 if v == nil { 5865 return fmt.Errorf("unexpected nil of type %T", v) 5866 } 5867 if value == nil { 5868 return nil 5869 } 5870 5871 shape, ok := value.(map[string]interface{}) 5872 if !ok { 5873 return fmt.Errorf("unexpected JSON type %v", value) 5874 } 5875 5876 var sv *UpdateDomainContactPrivacyOutput 5877 if *v == nil { 5878 sv = &UpdateDomainContactPrivacyOutput{} 5879 } else { 5880 sv = *v 5881 } 5882 5883 for key, value := range shape { 5884 switch key { 5885 case "OperationId": 5886 if value != nil { 5887 jtv, ok := value.(string) 5888 if !ok { 5889 return fmt.Errorf("expected OperationId to be of type string, got %T instead", value) 5890 } 5891 sv.OperationId = ptr.String(jtv) 5892 } 5893 5894 default: 5895 _, _ = key, value 5896 5897 } 5898 } 5899 *v = sv 5900 return nil 5901} 5902 5903func awsAwsjson11_deserializeOpDocumentUpdateDomainNameserversOutput(v **UpdateDomainNameserversOutput, value interface{}) error { 5904 if v == nil { 5905 return fmt.Errorf("unexpected nil of type %T", v) 5906 } 5907 if value == nil { 5908 return nil 5909 } 5910 5911 shape, ok := value.(map[string]interface{}) 5912 if !ok { 5913 return fmt.Errorf("unexpected JSON type %v", value) 5914 } 5915 5916 var sv *UpdateDomainNameserversOutput 5917 if *v == nil { 5918 sv = &UpdateDomainNameserversOutput{} 5919 } else { 5920 sv = *v 5921 } 5922 5923 for key, value := range shape { 5924 switch key { 5925 case "OperationId": 5926 if value != nil { 5927 jtv, ok := value.(string) 5928 if !ok { 5929 return fmt.Errorf("expected OperationId to be of type string, got %T instead", value) 5930 } 5931 sv.OperationId = ptr.String(jtv) 5932 } 5933 5934 default: 5935 _, _ = key, value 5936 5937 } 5938 } 5939 *v = sv 5940 return nil 5941} 5942 5943func awsAwsjson11_deserializeOpDocumentUpdateTagsForDomainOutput(v **UpdateTagsForDomainOutput, value interface{}) error { 5944 if v == nil { 5945 return fmt.Errorf("unexpected nil of type %T", v) 5946 } 5947 if value == nil { 5948 return nil 5949 } 5950 5951 shape, ok := value.(map[string]interface{}) 5952 if !ok { 5953 return fmt.Errorf("unexpected JSON type %v", value) 5954 } 5955 5956 var sv *UpdateTagsForDomainOutput 5957 if *v == nil { 5958 sv = &UpdateTagsForDomainOutput{} 5959 } else { 5960 sv = *v 5961 } 5962 5963 for key, value := range shape { 5964 switch key { 5965 default: 5966 _, _ = key, value 5967 5968 } 5969 } 5970 *v = sv 5971 return nil 5972} 5973 5974func awsAwsjson11_deserializeOpDocumentViewBillingOutput(v **ViewBillingOutput, value interface{}) error { 5975 if v == nil { 5976 return fmt.Errorf("unexpected nil of type %T", v) 5977 } 5978 if value == nil { 5979 return nil 5980 } 5981 5982 shape, ok := value.(map[string]interface{}) 5983 if !ok { 5984 return fmt.Errorf("unexpected JSON type %v", value) 5985 } 5986 5987 var sv *ViewBillingOutput 5988 if *v == nil { 5989 sv = &ViewBillingOutput{} 5990 } else { 5991 sv = *v 5992 } 5993 5994 for key, value := range shape { 5995 switch key { 5996 case "BillingRecords": 5997 if err := awsAwsjson11_deserializeDocumentBillingRecords(&sv.BillingRecords, value); err != nil { 5998 return err 5999 } 6000 6001 case "NextPageMarker": 6002 if value != nil { 6003 jtv, ok := value.(string) 6004 if !ok { 6005 return fmt.Errorf("expected PageMarker to be of type string, got %T instead", value) 6006 } 6007 sv.NextPageMarker = ptr.String(jtv) 6008 } 6009 6010 default: 6011 _, _ = key, value 6012 6013 } 6014 } 6015 *v = sv 6016 return nil 6017} 6018