1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package codepipeline 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/codepipeline/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 "io/ioutil" 20 "strings" 21) 22 23type awsAwsjson11_deserializeOpAcknowledgeJob struct { 24} 25 26func (*awsAwsjson11_deserializeOpAcknowledgeJob) ID() string { 27 return "OperationDeserializer" 28} 29 30func (m *awsAwsjson11_deserializeOpAcknowledgeJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 31 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 32) { 33 out, metadata, err = next.HandleDeserialize(ctx, in) 34 if err != nil { 35 return out, metadata, err 36 } 37 38 response, ok := out.RawResponse.(*smithyhttp.Response) 39 if !ok { 40 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 41 } 42 43 if response.StatusCode < 200 || response.StatusCode >= 300 { 44 return out, metadata, awsAwsjson11_deserializeOpErrorAcknowledgeJob(response, &metadata) 45 } 46 output := &AcknowledgeJobOutput{} 47 out.Result = output 48 49 var buff [1024]byte 50 ringBuffer := smithyio.NewRingBuffer(buff[:]) 51 52 body := io.TeeReader(response.Body, ringBuffer) 53 decoder := json.NewDecoder(body) 54 decoder.UseNumber() 55 var shape interface{} 56 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 57 var snapshot bytes.Buffer 58 io.Copy(&snapshot, ringBuffer) 59 err = &smithy.DeserializationError{ 60 Err: fmt.Errorf("failed to decode response body, %w", err), 61 Snapshot: snapshot.Bytes(), 62 } 63 return out, metadata, err 64 } 65 66 err = awsAwsjson11_deserializeOpDocumentAcknowledgeJobOutput(&output, shape) 67 if err != nil { 68 var snapshot bytes.Buffer 69 io.Copy(&snapshot, ringBuffer) 70 err = &smithy.DeserializationError{ 71 Err: fmt.Errorf("failed to decode response body, %w", err), 72 Snapshot: snapshot.Bytes(), 73 } 74 return out, metadata, err 75 } 76 77 return out, metadata, err 78} 79 80func awsAwsjson11_deserializeOpErrorAcknowledgeJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 81 var errorBuffer bytes.Buffer 82 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 83 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 84 } 85 errorBody := bytes.NewReader(errorBuffer.Bytes()) 86 87 errorCode := "UnknownError" 88 errorMessage := errorCode 89 90 code := response.Header.Get("X-Amzn-ErrorType") 91 if len(code) != 0 { 92 errorCode = restjson.SanitizeErrorCode(code) 93 } 94 95 var buff [1024]byte 96 ringBuffer := smithyio.NewRingBuffer(buff[:]) 97 98 body := io.TeeReader(errorBody, ringBuffer) 99 decoder := json.NewDecoder(body) 100 decoder.UseNumber() 101 code, message, err := restjson.GetErrorInfo(decoder) 102 if err != nil { 103 var snapshot bytes.Buffer 104 io.Copy(&snapshot, ringBuffer) 105 err = &smithy.DeserializationError{ 106 Err: fmt.Errorf("failed to decode response body, %w", err), 107 Snapshot: snapshot.Bytes(), 108 } 109 return err 110 } 111 112 errorBody.Seek(0, io.SeekStart) 113 if len(code) != 0 { 114 errorCode = restjson.SanitizeErrorCode(code) 115 } 116 if len(message) != 0 { 117 errorMessage = message 118 } 119 120 switch { 121 case strings.EqualFold("InvalidNonceException", errorCode): 122 return awsAwsjson11_deserializeErrorInvalidNonceException(response, errorBody) 123 124 case strings.EqualFold("JobNotFoundException", errorCode): 125 return awsAwsjson11_deserializeErrorJobNotFoundException(response, errorBody) 126 127 case strings.EqualFold("ValidationException", errorCode): 128 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 129 130 default: 131 genericError := &smithy.GenericAPIError{ 132 Code: errorCode, 133 Message: errorMessage, 134 } 135 return genericError 136 137 } 138} 139 140type awsAwsjson11_deserializeOpAcknowledgeThirdPartyJob struct { 141} 142 143func (*awsAwsjson11_deserializeOpAcknowledgeThirdPartyJob) ID() string { 144 return "OperationDeserializer" 145} 146 147func (m *awsAwsjson11_deserializeOpAcknowledgeThirdPartyJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 148 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 149) { 150 out, metadata, err = next.HandleDeserialize(ctx, in) 151 if err != nil { 152 return out, metadata, err 153 } 154 155 response, ok := out.RawResponse.(*smithyhttp.Response) 156 if !ok { 157 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 158 } 159 160 if response.StatusCode < 200 || response.StatusCode >= 300 { 161 return out, metadata, awsAwsjson11_deserializeOpErrorAcknowledgeThirdPartyJob(response, &metadata) 162 } 163 output := &AcknowledgeThirdPartyJobOutput{} 164 out.Result = output 165 166 var buff [1024]byte 167 ringBuffer := smithyio.NewRingBuffer(buff[:]) 168 169 body := io.TeeReader(response.Body, ringBuffer) 170 decoder := json.NewDecoder(body) 171 decoder.UseNumber() 172 var shape interface{} 173 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 174 var snapshot bytes.Buffer 175 io.Copy(&snapshot, ringBuffer) 176 err = &smithy.DeserializationError{ 177 Err: fmt.Errorf("failed to decode response body, %w", err), 178 Snapshot: snapshot.Bytes(), 179 } 180 return out, metadata, err 181 } 182 183 err = awsAwsjson11_deserializeOpDocumentAcknowledgeThirdPartyJobOutput(&output, shape) 184 if err != nil { 185 var snapshot bytes.Buffer 186 io.Copy(&snapshot, ringBuffer) 187 err = &smithy.DeserializationError{ 188 Err: fmt.Errorf("failed to decode response body, %w", err), 189 Snapshot: snapshot.Bytes(), 190 } 191 return out, metadata, err 192 } 193 194 return out, metadata, err 195} 196 197func awsAwsjson11_deserializeOpErrorAcknowledgeThirdPartyJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 198 var errorBuffer bytes.Buffer 199 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 200 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 201 } 202 errorBody := bytes.NewReader(errorBuffer.Bytes()) 203 204 errorCode := "UnknownError" 205 errorMessage := errorCode 206 207 code := response.Header.Get("X-Amzn-ErrorType") 208 if len(code) != 0 { 209 errorCode = restjson.SanitizeErrorCode(code) 210 } 211 212 var buff [1024]byte 213 ringBuffer := smithyio.NewRingBuffer(buff[:]) 214 215 body := io.TeeReader(errorBody, ringBuffer) 216 decoder := json.NewDecoder(body) 217 decoder.UseNumber() 218 code, message, err := restjson.GetErrorInfo(decoder) 219 if err != nil { 220 var snapshot bytes.Buffer 221 io.Copy(&snapshot, ringBuffer) 222 err = &smithy.DeserializationError{ 223 Err: fmt.Errorf("failed to decode response body, %w", err), 224 Snapshot: snapshot.Bytes(), 225 } 226 return err 227 } 228 229 errorBody.Seek(0, io.SeekStart) 230 if len(code) != 0 { 231 errorCode = restjson.SanitizeErrorCode(code) 232 } 233 if len(message) != 0 { 234 errorMessage = message 235 } 236 237 switch { 238 case strings.EqualFold("InvalidClientTokenException", errorCode): 239 return awsAwsjson11_deserializeErrorInvalidClientTokenException(response, errorBody) 240 241 case strings.EqualFold("InvalidNonceException", errorCode): 242 return awsAwsjson11_deserializeErrorInvalidNonceException(response, errorBody) 243 244 case strings.EqualFold("JobNotFoundException", errorCode): 245 return awsAwsjson11_deserializeErrorJobNotFoundException(response, errorBody) 246 247 case strings.EqualFold("ValidationException", errorCode): 248 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 249 250 default: 251 genericError := &smithy.GenericAPIError{ 252 Code: errorCode, 253 Message: errorMessage, 254 } 255 return genericError 256 257 } 258} 259 260type awsAwsjson11_deserializeOpCreateCustomActionType struct { 261} 262 263func (*awsAwsjson11_deserializeOpCreateCustomActionType) ID() string { 264 return "OperationDeserializer" 265} 266 267func (m *awsAwsjson11_deserializeOpCreateCustomActionType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 268 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 269) { 270 out, metadata, err = next.HandleDeserialize(ctx, in) 271 if err != nil { 272 return out, metadata, err 273 } 274 275 response, ok := out.RawResponse.(*smithyhttp.Response) 276 if !ok { 277 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 278 } 279 280 if response.StatusCode < 200 || response.StatusCode >= 300 { 281 return out, metadata, awsAwsjson11_deserializeOpErrorCreateCustomActionType(response, &metadata) 282 } 283 output := &CreateCustomActionTypeOutput{} 284 out.Result = output 285 286 var buff [1024]byte 287 ringBuffer := smithyio.NewRingBuffer(buff[:]) 288 289 body := io.TeeReader(response.Body, ringBuffer) 290 decoder := json.NewDecoder(body) 291 decoder.UseNumber() 292 var shape interface{} 293 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 294 var snapshot bytes.Buffer 295 io.Copy(&snapshot, ringBuffer) 296 err = &smithy.DeserializationError{ 297 Err: fmt.Errorf("failed to decode response body, %w", err), 298 Snapshot: snapshot.Bytes(), 299 } 300 return out, metadata, err 301 } 302 303 err = awsAwsjson11_deserializeOpDocumentCreateCustomActionTypeOutput(&output, shape) 304 if err != nil { 305 var snapshot bytes.Buffer 306 io.Copy(&snapshot, ringBuffer) 307 err = &smithy.DeserializationError{ 308 Err: fmt.Errorf("failed to decode response body, %w", err), 309 Snapshot: snapshot.Bytes(), 310 } 311 return out, metadata, err 312 } 313 314 return out, metadata, err 315} 316 317func awsAwsjson11_deserializeOpErrorCreateCustomActionType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 318 var errorBuffer bytes.Buffer 319 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 320 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 321 } 322 errorBody := bytes.NewReader(errorBuffer.Bytes()) 323 324 errorCode := "UnknownError" 325 errorMessage := errorCode 326 327 code := response.Header.Get("X-Amzn-ErrorType") 328 if len(code) != 0 { 329 errorCode = restjson.SanitizeErrorCode(code) 330 } 331 332 var buff [1024]byte 333 ringBuffer := smithyio.NewRingBuffer(buff[:]) 334 335 body := io.TeeReader(errorBody, ringBuffer) 336 decoder := json.NewDecoder(body) 337 decoder.UseNumber() 338 code, message, err := restjson.GetErrorInfo(decoder) 339 if err != nil { 340 var snapshot bytes.Buffer 341 io.Copy(&snapshot, ringBuffer) 342 err = &smithy.DeserializationError{ 343 Err: fmt.Errorf("failed to decode response body, %w", err), 344 Snapshot: snapshot.Bytes(), 345 } 346 return err 347 } 348 349 errorBody.Seek(0, io.SeekStart) 350 if len(code) != 0 { 351 errorCode = restjson.SanitizeErrorCode(code) 352 } 353 if len(message) != 0 { 354 errorMessage = message 355 } 356 357 switch { 358 case strings.EqualFold("ConcurrentModificationException", errorCode): 359 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 360 361 case strings.EqualFold("InvalidTagsException", errorCode): 362 return awsAwsjson11_deserializeErrorInvalidTagsException(response, errorBody) 363 364 case strings.EqualFold("LimitExceededException", errorCode): 365 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 366 367 case strings.EqualFold("TooManyTagsException", errorCode): 368 return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody) 369 370 case strings.EqualFold("ValidationException", errorCode): 371 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 372 373 default: 374 genericError := &smithy.GenericAPIError{ 375 Code: errorCode, 376 Message: errorMessage, 377 } 378 return genericError 379 380 } 381} 382 383type awsAwsjson11_deserializeOpCreatePipeline struct { 384} 385 386func (*awsAwsjson11_deserializeOpCreatePipeline) ID() string { 387 return "OperationDeserializer" 388} 389 390func (m *awsAwsjson11_deserializeOpCreatePipeline) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 391 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 392) { 393 out, metadata, err = next.HandleDeserialize(ctx, in) 394 if err != nil { 395 return out, metadata, err 396 } 397 398 response, ok := out.RawResponse.(*smithyhttp.Response) 399 if !ok { 400 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 401 } 402 403 if response.StatusCode < 200 || response.StatusCode >= 300 { 404 return out, metadata, awsAwsjson11_deserializeOpErrorCreatePipeline(response, &metadata) 405 } 406 output := &CreatePipelineOutput{} 407 out.Result = output 408 409 var buff [1024]byte 410 ringBuffer := smithyio.NewRingBuffer(buff[:]) 411 412 body := io.TeeReader(response.Body, ringBuffer) 413 decoder := json.NewDecoder(body) 414 decoder.UseNumber() 415 var shape interface{} 416 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 417 var snapshot bytes.Buffer 418 io.Copy(&snapshot, ringBuffer) 419 err = &smithy.DeserializationError{ 420 Err: fmt.Errorf("failed to decode response body, %w", err), 421 Snapshot: snapshot.Bytes(), 422 } 423 return out, metadata, err 424 } 425 426 err = awsAwsjson11_deserializeOpDocumentCreatePipelineOutput(&output, shape) 427 if err != nil { 428 var snapshot bytes.Buffer 429 io.Copy(&snapshot, ringBuffer) 430 err = &smithy.DeserializationError{ 431 Err: fmt.Errorf("failed to decode response body, %w", err), 432 Snapshot: snapshot.Bytes(), 433 } 434 return out, metadata, err 435 } 436 437 return out, metadata, err 438} 439 440func awsAwsjson11_deserializeOpErrorCreatePipeline(response *smithyhttp.Response, metadata *middleware.Metadata) error { 441 var errorBuffer bytes.Buffer 442 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 443 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 444 } 445 errorBody := bytes.NewReader(errorBuffer.Bytes()) 446 447 errorCode := "UnknownError" 448 errorMessage := errorCode 449 450 code := response.Header.Get("X-Amzn-ErrorType") 451 if len(code) != 0 { 452 errorCode = restjson.SanitizeErrorCode(code) 453 } 454 455 var buff [1024]byte 456 ringBuffer := smithyio.NewRingBuffer(buff[:]) 457 458 body := io.TeeReader(errorBody, ringBuffer) 459 decoder := json.NewDecoder(body) 460 decoder.UseNumber() 461 code, message, err := restjson.GetErrorInfo(decoder) 462 if err != nil { 463 var snapshot bytes.Buffer 464 io.Copy(&snapshot, ringBuffer) 465 err = &smithy.DeserializationError{ 466 Err: fmt.Errorf("failed to decode response body, %w", err), 467 Snapshot: snapshot.Bytes(), 468 } 469 return err 470 } 471 472 errorBody.Seek(0, io.SeekStart) 473 if len(code) != 0 { 474 errorCode = restjson.SanitizeErrorCode(code) 475 } 476 if len(message) != 0 { 477 errorMessage = message 478 } 479 480 switch { 481 case strings.EqualFold("ConcurrentModificationException", errorCode): 482 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 483 484 case strings.EqualFold("InvalidActionDeclarationException", errorCode): 485 return awsAwsjson11_deserializeErrorInvalidActionDeclarationException(response, errorBody) 486 487 case strings.EqualFold("InvalidBlockerDeclarationException", errorCode): 488 return awsAwsjson11_deserializeErrorInvalidBlockerDeclarationException(response, errorBody) 489 490 case strings.EqualFold("InvalidStageDeclarationException", errorCode): 491 return awsAwsjson11_deserializeErrorInvalidStageDeclarationException(response, errorBody) 492 493 case strings.EqualFold("InvalidStructureException", errorCode): 494 return awsAwsjson11_deserializeErrorInvalidStructureException(response, errorBody) 495 496 case strings.EqualFold("InvalidTagsException", errorCode): 497 return awsAwsjson11_deserializeErrorInvalidTagsException(response, errorBody) 498 499 case strings.EqualFold("LimitExceededException", errorCode): 500 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 501 502 case strings.EqualFold("PipelineNameInUseException", errorCode): 503 return awsAwsjson11_deserializeErrorPipelineNameInUseException(response, errorBody) 504 505 case strings.EqualFold("TooManyTagsException", errorCode): 506 return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody) 507 508 case strings.EqualFold("ValidationException", errorCode): 509 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 510 511 default: 512 genericError := &smithy.GenericAPIError{ 513 Code: errorCode, 514 Message: errorMessage, 515 } 516 return genericError 517 518 } 519} 520 521type awsAwsjson11_deserializeOpDeleteCustomActionType struct { 522} 523 524func (*awsAwsjson11_deserializeOpDeleteCustomActionType) ID() string { 525 return "OperationDeserializer" 526} 527 528func (m *awsAwsjson11_deserializeOpDeleteCustomActionType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 529 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 530) { 531 out, metadata, err = next.HandleDeserialize(ctx, in) 532 if err != nil { 533 return out, metadata, err 534 } 535 536 response, ok := out.RawResponse.(*smithyhttp.Response) 537 if !ok { 538 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 539 } 540 541 if response.StatusCode < 200 || response.StatusCode >= 300 { 542 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteCustomActionType(response, &metadata) 543 } 544 output := &DeleteCustomActionTypeOutput{} 545 out.Result = output 546 547 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 548 return out, metadata, &smithy.DeserializationError{ 549 Err: fmt.Errorf("failed to discard response body, %w", err), 550 } 551 } 552 553 return out, metadata, err 554} 555 556func awsAwsjson11_deserializeOpErrorDeleteCustomActionType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 557 var errorBuffer bytes.Buffer 558 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 559 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 560 } 561 errorBody := bytes.NewReader(errorBuffer.Bytes()) 562 563 errorCode := "UnknownError" 564 errorMessage := errorCode 565 566 code := response.Header.Get("X-Amzn-ErrorType") 567 if len(code) != 0 { 568 errorCode = restjson.SanitizeErrorCode(code) 569 } 570 571 var buff [1024]byte 572 ringBuffer := smithyio.NewRingBuffer(buff[:]) 573 574 body := io.TeeReader(errorBody, ringBuffer) 575 decoder := json.NewDecoder(body) 576 decoder.UseNumber() 577 code, message, err := restjson.GetErrorInfo(decoder) 578 if err != nil { 579 var snapshot bytes.Buffer 580 io.Copy(&snapshot, ringBuffer) 581 err = &smithy.DeserializationError{ 582 Err: fmt.Errorf("failed to decode response body, %w", err), 583 Snapshot: snapshot.Bytes(), 584 } 585 return err 586 } 587 588 errorBody.Seek(0, io.SeekStart) 589 if len(code) != 0 { 590 errorCode = restjson.SanitizeErrorCode(code) 591 } 592 if len(message) != 0 { 593 errorMessage = message 594 } 595 596 switch { 597 case strings.EqualFold("ConcurrentModificationException", errorCode): 598 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 599 600 case strings.EqualFold("ValidationException", errorCode): 601 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 602 603 default: 604 genericError := &smithy.GenericAPIError{ 605 Code: errorCode, 606 Message: errorMessage, 607 } 608 return genericError 609 610 } 611} 612 613type awsAwsjson11_deserializeOpDeletePipeline struct { 614} 615 616func (*awsAwsjson11_deserializeOpDeletePipeline) ID() string { 617 return "OperationDeserializer" 618} 619 620func (m *awsAwsjson11_deserializeOpDeletePipeline) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 621 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 622) { 623 out, metadata, err = next.HandleDeserialize(ctx, in) 624 if err != nil { 625 return out, metadata, err 626 } 627 628 response, ok := out.RawResponse.(*smithyhttp.Response) 629 if !ok { 630 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 631 } 632 633 if response.StatusCode < 200 || response.StatusCode >= 300 { 634 return out, metadata, awsAwsjson11_deserializeOpErrorDeletePipeline(response, &metadata) 635 } 636 output := &DeletePipelineOutput{} 637 out.Result = output 638 639 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 640 return out, metadata, &smithy.DeserializationError{ 641 Err: fmt.Errorf("failed to discard response body, %w", err), 642 } 643 } 644 645 return out, metadata, err 646} 647 648func awsAwsjson11_deserializeOpErrorDeletePipeline(response *smithyhttp.Response, metadata *middleware.Metadata) error { 649 var errorBuffer bytes.Buffer 650 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 651 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 652 } 653 errorBody := bytes.NewReader(errorBuffer.Bytes()) 654 655 errorCode := "UnknownError" 656 errorMessage := errorCode 657 658 code := response.Header.Get("X-Amzn-ErrorType") 659 if len(code) != 0 { 660 errorCode = restjson.SanitizeErrorCode(code) 661 } 662 663 var buff [1024]byte 664 ringBuffer := smithyio.NewRingBuffer(buff[:]) 665 666 body := io.TeeReader(errorBody, ringBuffer) 667 decoder := json.NewDecoder(body) 668 decoder.UseNumber() 669 code, message, err := restjson.GetErrorInfo(decoder) 670 if err != nil { 671 var snapshot bytes.Buffer 672 io.Copy(&snapshot, ringBuffer) 673 err = &smithy.DeserializationError{ 674 Err: fmt.Errorf("failed to decode response body, %w", err), 675 Snapshot: snapshot.Bytes(), 676 } 677 return err 678 } 679 680 errorBody.Seek(0, io.SeekStart) 681 if len(code) != 0 { 682 errorCode = restjson.SanitizeErrorCode(code) 683 } 684 if len(message) != 0 { 685 errorMessage = message 686 } 687 688 switch { 689 case strings.EqualFold("ConcurrentModificationException", errorCode): 690 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 691 692 case strings.EqualFold("ValidationException", errorCode): 693 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 694 695 default: 696 genericError := &smithy.GenericAPIError{ 697 Code: errorCode, 698 Message: errorMessage, 699 } 700 return genericError 701 702 } 703} 704 705type awsAwsjson11_deserializeOpDeleteWebhook struct { 706} 707 708func (*awsAwsjson11_deserializeOpDeleteWebhook) ID() string { 709 return "OperationDeserializer" 710} 711 712func (m *awsAwsjson11_deserializeOpDeleteWebhook) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 713 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 714) { 715 out, metadata, err = next.HandleDeserialize(ctx, in) 716 if err != nil { 717 return out, metadata, err 718 } 719 720 response, ok := out.RawResponse.(*smithyhttp.Response) 721 if !ok { 722 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 723 } 724 725 if response.StatusCode < 200 || response.StatusCode >= 300 { 726 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteWebhook(response, &metadata) 727 } 728 output := &DeleteWebhookOutput{} 729 out.Result = output 730 731 var buff [1024]byte 732 ringBuffer := smithyio.NewRingBuffer(buff[:]) 733 734 body := io.TeeReader(response.Body, ringBuffer) 735 decoder := json.NewDecoder(body) 736 decoder.UseNumber() 737 var shape interface{} 738 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 739 var snapshot bytes.Buffer 740 io.Copy(&snapshot, ringBuffer) 741 err = &smithy.DeserializationError{ 742 Err: fmt.Errorf("failed to decode response body, %w", err), 743 Snapshot: snapshot.Bytes(), 744 } 745 return out, metadata, err 746 } 747 748 err = awsAwsjson11_deserializeOpDocumentDeleteWebhookOutput(&output, shape) 749 if err != nil { 750 var snapshot bytes.Buffer 751 io.Copy(&snapshot, ringBuffer) 752 err = &smithy.DeserializationError{ 753 Err: fmt.Errorf("failed to decode response body, %w", err), 754 Snapshot: snapshot.Bytes(), 755 } 756 return out, metadata, err 757 } 758 759 return out, metadata, err 760} 761 762func awsAwsjson11_deserializeOpErrorDeleteWebhook(response *smithyhttp.Response, metadata *middleware.Metadata) error { 763 var errorBuffer bytes.Buffer 764 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 765 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 766 } 767 errorBody := bytes.NewReader(errorBuffer.Bytes()) 768 769 errorCode := "UnknownError" 770 errorMessage := errorCode 771 772 code := response.Header.Get("X-Amzn-ErrorType") 773 if len(code) != 0 { 774 errorCode = restjson.SanitizeErrorCode(code) 775 } 776 777 var buff [1024]byte 778 ringBuffer := smithyio.NewRingBuffer(buff[:]) 779 780 body := io.TeeReader(errorBody, ringBuffer) 781 decoder := json.NewDecoder(body) 782 decoder.UseNumber() 783 code, message, err := restjson.GetErrorInfo(decoder) 784 if err != nil { 785 var snapshot bytes.Buffer 786 io.Copy(&snapshot, ringBuffer) 787 err = &smithy.DeserializationError{ 788 Err: fmt.Errorf("failed to decode response body, %w", err), 789 Snapshot: snapshot.Bytes(), 790 } 791 return err 792 } 793 794 errorBody.Seek(0, io.SeekStart) 795 if len(code) != 0 { 796 errorCode = restjson.SanitizeErrorCode(code) 797 } 798 if len(message) != 0 { 799 errorMessage = message 800 } 801 802 switch { 803 case strings.EqualFold("ConcurrentModificationException", errorCode): 804 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 805 806 case strings.EqualFold("ValidationException", errorCode): 807 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 808 809 default: 810 genericError := &smithy.GenericAPIError{ 811 Code: errorCode, 812 Message: errorMessage, 813 } 814 return genericError 815 816 } 817} 818 819type awsAwsjson11_deserializeOpDeregisterWebhookWithThirdParty struct { 820} 821 822func (*awsAwsjson11_deserializeOpDeregisterWebhookWithThirdParty) ID() string { 823 return "OperationDeserializer" 824} 825 826func (m *awsAwsjson11_deserializeOpDeregisterWebhookWithThirdParty) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 827 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 828) { 829 out, metadata, err = next.HandleDeserialize(ctx, in) 830 if err != nil { 831 return out, metadata, err 832 } 833 834 response, ok := out.RawResponse.(*smithyhttp.Response) 835 if !ok { 836 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 837 } 838 839 if response.StatusCode < 200 || response.StatusCode >= 300 { 840 return out, metadata, awsAwsjson11_deserializeOpErrorDeregisterWebhookWithThirdParty(response, &metadata) 841 } 842 output := &DeregisterWebhookWithThirdPartyOutput{} 843 out.Result = output 844 845 var buff [1024]byte 846 ringBuffer := smithyio.NewRingBuffer(buff[:]) 847 848 body := io.TeeReader(response.Body, ringBuffer) 849 decoder := json.NewDecoder(body) 850 decoder.UseNumber() 851 var shape interface{} 852 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 853 var snapshot bytes.Buffer 854 io.Copy(&snapshot, ringBuffer) 855 err = &smithy.DeserializationError{ 856 Err: fmt.Errorf("failed to decode response body, %w", err), 857 Snapshot: snapshot.Bytes(), 858 } 859 return out, metadata, err 860 } 861 862 err = awsAwsjson11_deserializeOpDocumentDeregisterWebhookWithThirdPartyOutput(&output, shape) 863 if err != nil { 864 var snapshot bytes.Buffer 865 io.Copy(&snapshot, ringBuffer) 866 err = &smithy.DeserializationError{ 867 Err: fmt.Errorf("failed to decode response body, %w", err), 868 Snapshot: snapshot.Bytes(), 869 } 870 return out, metadata, err 871 } 872 873 return out, metadata, err 874} 875 876func awsAwsjson11_deserializeOpErrorDeregisterWebhookWithThirdParty(response *smithyhttp.Response, metadata *middleware.Metadata) error { 877 var errorBuffer bytes.Buffer 878 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 879 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 880 } 881 errorBody := bytes.NewReader(errorBuffer.Bytes()) 882 883 errorCode := "UnknownError" 884 errorMessage := errorCode 885 886 code := response.Header.Get("X-Amzn-ErrorType") 887 if len(code) != 0 { 888 errorCode = restjson.SanitizeErrorCode(code) 889 } 890 891 var buff [1024]byte 892 ringBuffer := smithyio.NewRingBuffer(buff[:]) 893 894 body := io.TeeReader(errorBody, ringBuffer) 895 decoder := json.NewDecoder(body) 896 decoder.UseNumber() 897 code, message, err := restjson.GetErrorInfo(decoder) 898 if err != nil { 899 var snapshot bytes.Buffer 900 io.Copy(&snapshot, ringBuffer) 901 err = &smithy.DeserializationError{ 902 Err: fmt.Errorf("failed to decode response body, %w", err), 903 Snapshot: snapshot.Bytes(), 904 } 905 return err 906 } 907 908 errorBody.Seek(0, io.SeekStart) 909 if len(code) != 0 { 910 errorCode = restjson.SanitizeErrorCode(code) 911 } 912 if len(message) != 0 { 913 errorMessage = message 914 } 915 916 switch { 917 case strings.EqualFold("ValidationException", errorCode): 918 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 919 920 case strings.EqualFold("WebhookNotFoundException", errorCode): 921 return awsAwsjson11_deserializeErrorWebhookNotFoundException(response, errorBody) 922 923 default: 924 genericError := &smithy.GenericAPIError{ 925 Code: errorCode, 926 Message: errorMessage, 927 } 928 return genericError 929 930 } 931} 932 933type awsAwsjson11_deserializeOpDisableStageTransition struct { 934} 935 936func (*awsAwsjson11_deserializeOpDisableStageTransition) ID() string { 937 return "OperationDeserializer" 938} 939 940func (m *awsAwsjson11_deserializeOpDisableStageTransition) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 941 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 942) { 943 out, metadata, err = next.HandleDeserialize(ctx, in) 944 if err != nil { 945 return out, metadata, err 946 } 947 948 response, ok := out.RawResponse.(*smithyhttp.Response) 949 if !ok { 950 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 951 } 952 953 if response.StatusCode < 200 || response.StatusCode >= 300 { 954 return out, metadata, awsAwsjson11_deserializeOpErrorDisableStageTransition(response, &metadata) 955 } 956 output := &DisableStageTransitionOutput{} 957 out.Result = output 958 959 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 960 return out, metadata, &smithy.DeserializationError{ 961 Err: fmt.Errorf("failed to discard response body, %w", err), 962 } 963 } 964 965 return out, metadata, err 966} 967 968func awsAwsjson11_deserializeOpErrorDisableStageTransition(response *smithyhttp.Response, metadata *middleware.Metadata) error { 969 var errorBuffer bytes.Buffer 970 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 971 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 972 } 973 errorBody := bytes.NewReader(errorBuffer.Bytes()) 974 975 errorCode := "UnknownError" 976 errorMessage := errorCode 977 978 code := response.Header.Get("X-Amzn-ErrorType") 979 if len(code) != 0 { 980 errorCode = restjson.SanitizeErrorCode(code) 981 } 982 983 var buff [1024]byte 984 ringBuffer := smithyio.NewRingBuffer(buff[:]) 985 986 body := io.TeeReader(errorBody, ringBuffer) 987 decoder := json.NewDecoder(body) 988 decoder.UseNumber() 989 code, message, err := restjson.GetErrorInfo(decoder) 990 if err != nil { 991 var snapshot bytes.Buffer 992 io.Copy(&snapshot, ringBuffer) 993 err = &smithy.DeserializationError{ 994 Err: fmt.Errorf("failed to decode response body, %w", err), 995 Snapshot: snapshot.Bytes(), 996 } 997 return err 998 } 999 1000 errorBody.Seek(0, io.SeekStart) 1001 if len(code) != 0 { 1002 errorCode = restjson.SanitizeErrorCode(code) 1003 } 1004 if len(message) != 0 { 1005 errorMessage = message 1006 } 1007 1008 switch { 1009 case strings.EqualFold("PipelineNotFoundException", errorCode): 1010 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 1011 1012 case strings.EqualFold("StageNotFoundException", errorCode): 1013 return awsAwsjson11_deserializeErrorStageNotFoundException(response, errorBody) 1014 1015 case strings.EqualFold("ValidationException", errorCode): 1016 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1017 1018 default: 1019 genericError := &smithy.GenericAPIError{ 1020 Code: errorCode, 1021 Message: errorMessage, 1022 } 1023 return genericError 1024 1025 } 1026} 1027 1028type awsAwsjson11_deserializeOpEnableStageTransition struct { 1029} 1030 1031func (*awsAwsjson11_deserializeOpEnableStageTransition) ID() string { 1032 return "OperationDeserializer" 1033} 1034 1035func (m *awsAwsjson11_deserializeOpEnableStageTransition) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1036 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1037) { 1038 out, metadata, err = next.HandleDeserialize(ctx, in) 1039 if err != nil { 1040 return out, metadata, err 1041 } 1042 1043 response, ok := out.RawResponse.(*smithyhttp.Response) 1044 if !ok { 1045 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1046 } 1047 1048 if response.StatusCode < 200 || response.StatusCode >= 300 { 1049 return out, metadata, awsAwsjson11_deserializeOpErrorEnableStageTransition(response, &metadata) 1050 } 1051 output := &EnableStageTransitionOutput{} 1052 out.Result = output 1053 1054 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1055 return out, metadata, &smithy.DeserializationError{ 1056 Err: fmt.Errorf("failed to discard response body, %w", err), 1057 } 1058 } 1059 1060 return out, metadata, err 1061} 1062 1063func awsAwsjson11_deserializeOpErrorEnableStageTransition(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1064 var errorBuffer bytes.Buffer 1065 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1066 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1067 } 1068 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1069 1070 errorCode := "UnknownError" 1071 errorMessage := errorCode 1072 1073 code := response.Header.Get("X-Amzn-ErrorType") 1074 if len(code) != 0 { 1075 errorCode = restjson.SanitizeErrorCode(code) 1076 } 1077 1078 var buff [1024]byte 1079 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1080 1081 body := io.TeeReader(errorBody, ringBuffer) 1082 decoder := json.NewDecoder(body) 1083 decoder.UseNumber() 1084 code, message, err := restjson.GetErrorInfo(decoder) 1085 if err != nil { 1086 var snapshot bytes.Buffer 1087 io.Copy(&snapshot, ringBuffer) 1088 err = &smithy.DeserializationError{ 1089 Err: fmt.Errorf("failed to decode response body, %w", err), 1090 Snapshot: snapshot.Bytes(), 1091 } 1092 return err 1093 } 1094 1095 errorBody.Seek(0, io.SeekStart) 1096 if len(code) != 0 { 1097 errorCode = restjson.SanitizeErrorCode(code) 1098 } 1099 if len(message) != 0 { 1100 errorMessage = message 1101 } 1102 1103 switch { 1104 case strings.EqualFold("PipelineNotFoundException", errorCode): 1105 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 1106 1107 case strings.EqualFold("StageNotFoundException", errorCode): 1108 return awsAwsjson11_deserializeErrorStageNotFoundException(response, errorBody) 1109 1110 case strings.EqualFold("ValidationException", errorCode): 1111 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1112 1113 default: 1114 genericError := &smithy.GenericAPIError{ 1115 Code: errorCode, 1116 Message: errorMessage, 1117 } 1118 return genericError 1119 1120 } 1121} 1122 1123type awsAwsjson11_deserializeOpGetActionType struct { 1124} 1125 1126func (*awsAwsjson11_deserializeOpGetActionType) ID() string { 1127 return "OperationDeserializer" 1128} 1129 1130func (m *awsAwsjson11_deserializeOpGetActionType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1131 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1132) { 1133 out, metadata, err = next.HandleDeserialize(ctx, in) 1134 if err != nil { 1135 return out, metadata, err 1136 } 1137 1138 response, ok := out.RawResponse.(*smithyhttp.Response) 1139 if !ok { 1140 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1141 } 1142 1143 if response.StatusCode < 200 || response.StatusCode >= 300 { 1144 return out, metadata, awsAwsjson11_deserializeOpErrorGetActionType(response, &metadata) 1145 } 1146 output := &GetActionTypeOutput{} 1147 out.Result = output 1148 1149 var buff [1024]byte 1150 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1151 1152 body := io.TeeReader(response.Body, ringBuffer) 1153 decoder := json.NewDecoder(body) 1154 decoder.UseNumber() 1155 var shape interface{} 1156 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1157 var snapshot bytes.Buffer 1158 io.Copy(&snapshot, ringBuffer) 1159 err = &smithy.DeserializationError{ 1160 Err: fmt.Errorf("failed to decode response body, %w", err), 1161 Snapshot: snapshot.Bytes(), 1162 } 1163 return out, metadata, err 1164 } 1165 1166 err = awsAwsjson11_deserializeOpDocumentGetActionTypeOutput(&output, shape) 1167 if err != nil { 1168 var snapshot bytes.Buffer 1169 io.Copy(&snapshot, ringBuffer) 1170 err = &smithy.DeserializationError{ 1171 Err: fmt.Errorf("failed to decode response body, %w", err), 1172 Snapshot: snapshot.Bytes(), 1173 } 1174 return out, metadata, err 1175 } 1176 1177 return out, metadata, err 1178} 1179 1180func awsAwsjson11_deserializeOpErrorGetActionType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1181 var errorBuffer bytes.Buffer 1182 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1183 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1184 } 1185 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1186 1187 errorCode := "UnknownError" 1188 errorMessage := errorCode 1189 1190 code := response.Header.Get("X-Amzn-ErrorType") 1191 if len(code) != 0 { 1192 errorCode = restjson.SanitizeErrorCode(code) 1193 } 1194 1195 var buff [1024]byte 1196 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1197 1198 body := io.TeeReader(errorBody, ringBuffer) 1199 decoder := json.NewDecoder(body) 1200 decoder.UseNumber() 1201 code, message, err := restjson.GetErrorInfo(decoder) 1202 if err != nil { 1203 var snapshot bytes.Buffer 1204 io.Copy(&snapshot, ringBuffer) 1205 err = &smithy.DeserializationError{ 1206 Err: fmt.Errorf("failed to decode response body, %w", err), 1207 Snapshot: snapshot.Bytes(), 1208 } 1209 return err 1210 } 1211 1212 errorBody.Seek(0, io.SeekStart) 1213 if len(code) != 0 { 1214 errorCode = restjson.SanitizeErrorCode(code) 1215 } 1216 if len(message) != 0 { 1217 errorMessage = message 1218 } 1219 1220 switch { 1221 case strings.EqualFold("ActionTypeNotFoundException", errorCode): 1222 return awsAwsjson11_deserializeErrorActionTypeNotFoundException(response, errorBody) 1223 1224 case strings.EqualFold("ValidationException", errorCode): 1225 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1226 1227 default: 1228 genericError := &smithy.GenericAPIError{ 1229 Code: errorCode, 1230 Message: errorMessage, 1231 } 1232 return genericError 1233 1234 } 1235} 1236 1237type awsAwsjson11_deserializeOpGetJobDetails struct { 1238} 1239 1240func (*awsAwsjson11_deserializeOpGetJobDetails) ID() string { 1241 return "OperationDeserializer" 1242} 1243 1244func (m *awsAwsjson11_deserializeOpGetJobDetails) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1245 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1246) { 1247 out, metadata, err = next.HandleDeserialize(ctx, in) 1248 if err != nil { 1249 return out, metadata, err 1250 } 1251 1252 response, ok := out.RawResponse.(*smithyhttp.Response) 1253 if !ok { 1254 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1255 } 1256 1257 if response.StatusCode < 200 || response.StatusCode >= 300 { 1258 return out, metadata, awsAwsjson11_deserializeOpErrorGetJobDetails(response, &metadata) 1259 } 1260 output := &GetJobDetailsOutput{} 1261 out.Result = output 1262 1263 var buff [1024]byte 1264 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1265 1266 body := io.TeeReader(response.Body, ringBuffer) 1267 decoder := json.NewDecoder(body) 1268 decoder.UseNumber() 1269 var shape interface{} 1270 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1271 var snapshot bytes.Buffer 1272 io.Copy(&snapshot, ringBuffer) 1273 err = &smithy.DeserializationError{ 1274 Err: fmt.Errorf("failed to decode response body, %w", err), 1275 Snapshot: snapshot.Bytes(), 1276 } 1277 return out, metadata, err 1278 } 1279 1280 err = awsAwsjson11_deserializeOpDocumentGetJobDetailsOutput(&output, shape) 1281 if err != nil { 1282 var snapshot bytes.Buffer 1283 io.Copy(&snapshot, ringBuffer) 1284 err = &smithy.DeserializationError{ 1285 Err: fmt.Errorf("failed to decode response body, %w", err), 1286 Snapshot: snapshot.Bytes(), 1287 } 1288 return out, metadata, err 1289 } 1290 1291 return out, metadata, err 1292} 1293 1294func awsAwsjson11_deserializeOpErrorGetJobDetails(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1295 var errorBuffer bytes.Buffer 1296 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1297 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1298 } 1299 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1300 1301 errorCode := "UnknownError" 1302 errorMessage := errorCode 1303 1304 code := response.Header.Get("X-Amzn-ErrorType") 1305 if len(code) != 0 { 1306 errorCode = restjson.SanitizeErrorCode(code) 1307 } 1308 1309 var buff [1024]byte 1310 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1311 1312 body := io.TeeReader(errorBody, ringBuffer) 1313 decoder := json.NewDecoder(body) 1314 decoder.UseNumber() 1315 code, message, err := restjson.GetErrorInfo(decoder) 1316 if err != nil { 1317 var snapshot bytes.Buffer 1318 io.Copy(&snapshot, ringBuffer) 1319 err = &smithy.DeserializationError{ 1320 Err: fmt.Errorf("failed to decode response body, %w", err), 1321 Snapshot: snapshot.Bytes(), 1322 } 1323 return err 1324 } 1325 1326 errorBody.Seek(0, io.SeekStart) 1327 if len(code) != 0 { 1328 errorCode = restjson.SanitizeErrorCode(code) 1329 } 1330 if len(message) != 0 { 1331 errorMessage = message 1332 } 1333 1334 switch { 1335 case strings.EqualFold("JobNotFoundException", errorCode): 1336 return awsAwsjson11_deserializeErrorJobNotFoundException(response, errorBody) 1337 1338 case strings.EqualFold("ValidationException", errorCode): 1339 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1340 1341 default: 1342 genericError := &smithy.GenericAPIError{ 1343 Code: errorCode, 1344 Message: errorMessage, 1345 } 1346 return genericError 1347 1348 } 1349} 1350 1351type awsAwsjson11_deserializeOpGetPipeline struct { 1352} 1353 1354func (*awsAwsjson11_deserializeOpGetPipeline) ID() string { 1355 return "OperationDeserializer" 1356} 1357 1358func (m *awsAwsjson11_deserializeOpGetPipeline) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1359 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1360) { 1361 out, metadata, err = next.HandleDeserialize(ctx, in) 1362 if err != nil { 1363 return out, metadata, err 1364 } 1365 1366 response, ok := out.RawResponse.(*smithyhttp.Response) 1367 if !ok { 1368 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1369 } 1370 1371 if response.StatusCode < 200 || response.StatusCode >= 300 { 1372 return out, metadata, awsAwsjson11_deserializeOpErrorGetPipeline(response, &metadata) 1373 } 1374 output := &GetPipelineOutput{} 1375 out.Result = output 1376 1377 var buff [1024]byte 1378 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1379 1380 body := io.TeeReader(response.Body, ringBuffer) 1381 decoder := json.NewDecoder(body) 1382 decoder.UseNumber() 1383 var shape interface{} 1384 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1385 var snapshot bytes.Buffer 1386 io.Copy(&snapshot, ringBuffer) 1387 err = &smithy.DeserializationError{ 1388 Err: fmt.Errorf("failed to decode response body, %w", err), 1389 Snapshot: snapshot.Bytes(), 1390 } 1391 return out, metadata, err 1392 } 1393 1394 err = awsAwsjson11_deserializeOpDocumentGetPipelineOutput(&output, shape) 1395 if err != nil { 1396 var snapshot bytes.Buffer 1397 io.Copy(&snapshot, ringBuffer) 1398 err = &smithy.DeserializationError{ 1399 Err: fmt.Errorf("failed to decode response body, %w", err), 1400 Snapshot: snapshot.Bytes(), 1401 } 1402 return out, metadata, err 1403 } 1404 1405 return out, metadata, err 1406} 1407 1408func awsAwsjson11_deserializeOpErrorGetPipeline(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1409 var errorBuffer bytes.Buffer 1410 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1411 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1412 } 1413 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1414 1415 errorCode := "UnknownError" 1416 errorMessage := errorCode 1417 1418 code := response.Header.Get("X-Amzn-ErrorType") 1419 if len(code) != 0 { 1420 errorCode = restjson.SanitizeErrorCode(code) 1421 } 1422 1423 var buff [1024]byte 1424 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1425 1426 body := io.TeeReader(errorBody, ringBuffer) 1427 decoder := json.NewDecoder(body) 1428 decoder.UseNumber() 1429 code, message, err := restjson.GetErrorInfo(decoder) 1430 if err != nil { 1431 var snapshot bytes.Buffer 1432 io.Copy(&snapshot, ringBuffer) 1433 err = &smithy.DeserializationError{ 1434 Err: fmt.Errorf("failed to decode response body, %w", err), 1435 Snapshot: snapshot.Bytes(), 1436 } 1437 return err 1438 } 1439 1440 errorBody.Seek(0, io.SeekStart) 1441 if len(code) != 0 { 1442 errorCode = restjson.SanitizeErrorCode(code) 1443 } 1444 if len(message) != 0 { 1445 errorMessage = message 1446 } 1447 1448 switch { 1449 case strings.EqualFold("PipelineNotFoundException", errorCode): 1450 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 1451 1452 case strings.EqualFold("PipelineVersionNotFoundException", errorCode): 1453 return awsAwsjson11_deserializeErrorPipelineVersionNotFoundException(response, errorBody) 1454 1455 case strings.EqualFold("ValidationException", errorCode): 1456 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1457 1458 default: 1459 genericError := &smithy.GenericAPIError{ 1460 Code: errorCode, 1461 Message: errorMessage, 1462 } 1463 return genericError 1464 1465 } 1466} 1467 1468type awsAwsjson11_deserializeOpGetPipelineExecution struct { 1469} 1470 1471func (*awsAwsjson11_deserializeOpGetPipelineExecution) ID() string { 1472 return "OperationDeserializer" 1473} 1474 1475func (m *awsAwsjson11_deserializeOpGetPipelineExecution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1476 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1477) { 1478 out, metadata, err = next.HandleDeserialize(ctx, in) 1479 if err != nil { 1480 return out, metadata, err 1481 } 1482 1483 response, ok := out.RawResponse.(*smithyhttp.Response) 1484 if !ok { 1485 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1486 } 1487 1488 if response.StatusCode < 200 || response.StatusCode >= 300 { 1489 return out, metadata, awsAwsjson11_deserializeOpErrorGetPipelineExecution(response, &metadata) 1490 } 1491 output := &GetPipelineExecutionOutput{} 1492 out.Result = output 1493 1494 var buff [1024]byte 1495 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1496 1497 body := io.TeeReader(response.Body, ringBuffer) 1498 decoder := json.NewDecoder(body) 1499 decoder.UseNumber() 1500 var shape interface{} 1501 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1502 var snapshot bytes.Buffer 1503 io.Copy(&snapshot, ringBuffer) 1504 err = &smithy.DeserializationError{ 1505 Err: fmt.Errorf("failed to decode response body, %w", err), 1506 Snapshot: snapshot.Bytes(), 1507 } 1508 return out, metadata, err 1509 } 1510 1511 err = awsAwsjson11_deserializeOpDocumentGetPipelineExecutionOutput(&output, shape) 1512 if err != nil { 1513 var snapshot bytes.Buffer 1514 io.Copy(&snapshot, ringBuffer) 1515 err = &smithy.DeserializationError{ 1516 Err: fmt.Errorf("failed to decode response body, %w", err), 1517 Snapshot: snapshot.Bytes(), 1518 } 1519 return out, metadata, err 1520 } 1521 1522 return out, metadata, err 1523} 1524 1525func awsAwsjson11_deserializeOpErrorGetPipelineExecution(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1526 var errorBuffer bytes.Buffer 1527 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1528 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1529 } 1530 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1531 1532 errorCode := "UnknownError" 1533 errorMessage := errorCode 1534 1535 code := response.Header.Get("X-Amzn-ErrorType") 1536 if len(code) != 0 { 1537 errorCode = restjson.SanitizeErrorCode(code) 1538 } 1539 1540 var buff [1024]byte 1541 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1542 1543 body := io.TeeReader(errorBody, ringBuffer) 1544 decoder := json.NewDecoder(body) 1545 decoder.UseNumber() 1546 code, message, err := restjson.GetErrorInfo(decoder) 1547 if err != nil { 1548 var snapshot bytes.Buffer 1549 io.Copy(&snapshot, ringBuffer) 1550 err = &smithy.DeserializationError{ 1551 Err: fmt.Errorf("failed to decode response body, %w", err), 1552 Snapshot: snapshot.Bytes(), 1553 } 1554 return err 1555 } 1556 1557 errorBody.Seek(0, io.SeekStart) 1558 if len(code) != 0 { 1559 errorCode = restjson.SanitizeErrorCode(code) 1560 } 1561 if len(message) != 0 { 1562 errorMessage = message 1563 } 1564 1565 switch { 1566 case strings.EqualFold("PipelineExecutionNotFoundException", errorCode): 1567 return awsAwsjson11_deserializeErrorPipelineExecutionNotFoundException(response, errorBody) 1568 1569 case strings.EqualFold("PipelineNotFoundException", errorCode): 1570 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 1571 1572 case strings.EqualFold("ValidationException", errorCode): 1573 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1574 1575 default: 1576 genericError := &smithy.GenericAPIError{ 1577 Code: errorCode, 1578 Message: errorMessage, 1579 } 1580 return genericError 1581 1582 } 1583} 1584 1585type awsAwsjson11_deserializeOpGetPipelineState struct { 1586} 1587 1588func (*awsAwsjson11_deserializeOpGetPipelineState) ID() string { 1589 return "OperationDeserializer" 1590} 1591 1592func (m *awsAwsjson11_deserializeOpGetPipelineState) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1593 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1594) { 1595 out, metadata, err = next.HandleDeserialize(ctx, in) 1596 if err != nil { 1597 return out, metadata, err 1598 } 1599 1600 response, ok := out.RawResponse.(*smithyhttp.Response) 1601 if !ok { 1602 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1603 } 1604 1605 if response.StatusCode < 200 || response.StatusCode >= 300 { 1606 return out, metadata, awsAwsjson11_deserializeOpErrorGetPipelineState(response, &metadata) 1607 } 1608 output := &GetPipelineStateOutput{} 1609 out.Result = output 1610 1611 var buff [1024]byte 1612 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1613 1614 body := io.TeeReader(response.Body, ringBuffer) 1615 decoder := json.NewDecoder(body) 1616 decoder.UseNumber() 1617 var shape interface{} 1618 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1619 var snapshot bytes.Buffer 1620 io.Copy(&snapshot, ringBuffer) 1621 err = &smithy.DeserializationError{ 1622 Err: fmt.Errorf("failed to decode response body, %w", err), 1623 Snapshot: snapshot.Bytes(), 1624 } 1625 return out, metadata, err 1626 } 1627 1628 err = awsAwsjson11_deserializeOpDocumentGetPipelineStateOutput(&output, shape) 1629 if err != nil { 1630 var snapshot bytes.Buffer 1631 io.Copy(&snapshot, ringBuffer) 1632 err = &smithy.DeserializationError{ 1633 Err: fmt.Errorf("failed to decode response body, %w", err), 1634 Snapshot: snapshot.Bytes(), 1635 } 1636 return out, metadata, err 1637 } 1638 1639 return out, metadata, err 1640} 1641 1642func awsAwsjson11_deserializeOpErrorGetPipelineState(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1643 var errorBuffer bytes.Buffer 1644 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1645 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1646 } 1647 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1648 1649 errorCode := "UnknownError" 1650 errorMessage := errorCode 1651 1652 code := response.Header.Get("X-Amzn-ErrorType") 1653 if len(code) != 0 { 1654 errorCode = restjson.SanitizeErrorCode(code) 1655 } 1656 1657 var buff [1024]byte 1658 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1659 1660 body := io.TeeReader(errorBody, ringBuffer) 1661 decoder := json.NewDecoder(body) 1662 decoder.UseNumber() 1663 code, message, err := restjson.GetErrorInfo(decoder) 1664 if err != nil { 1665 var snapshot bytes.Buffer 1666 io.Copy(&snapshot, ringBuffer) 1667 err = &smithy.DeserializationError{ 1668 Err: fmt.Errorf("failed to decode response body, %w", err), 1669 Snapshot: snapshot.Bytes(), 1670 } 1671 return err 1672 } 1673 1674 errorBody.Seek(0, io.SeekStart) 1675 if len(code) != 0 { 1676 errorCode = restjson.SanitizeErrorCode(code) 1677 } 1678 if len(message) != 0 { 1679 errorMessage = message 1680 } 1681 1682 switch { 1683 case strings.EqualFold("PipelineNotFoundException", errorCode): 1684 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 1685 1686 case strings.EqualFold("ValidationException", errorCode): 1687 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1688 1689 default: 1690 genericError := &smithy.GenericAPIError{ 1691 Code: errorCode, 1692 Message: errorMessage, 1693 } 1694 return genericError 1695 1696 } 1697} 1698 1699type awsAwsjson11_deserializeOpGetThirdPartyJobDetails struct { 1700} 1701 1702func (*awsAwsjson11_deserializeOpGetThirdPartyJobDetails) ID() string { 1703 return "OperationDeserializer" 1704} 1705 1706func (m *awsAwsjson11_deserializeOpGetThirdPartyJobDetails) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1707 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1708) { 1709 out, metadata, err = next.HandleDeserialize(ctx, in) 1710 if err != nil { 1711 return out, metadata, err 1712 } 1713 1714 response, ok := out.RawResponse.(*smithyhttp.Response) 1715 if !ok { 1716 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1717 } 1718 1719 if response.StatusCode < 200 || response.StatusCode >= 300 { 1720 return out, metadata, awsAwsjson11_deserializeOpErrorGetThirdPartyJobDetails(response, &metadata) 1721 } 1722 output := &GetThirdPartyJobDetailsOutput{} 1723 out.Result = output 1724 1725 var buff [1024]byte 1726 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1727 1728 body := io.TeeReader(response.Body, ringBuffer) 1729 decoder := json.NewDecoder(body) 1730 decoder.UseNumber() 1731 var shape interface{} 1732 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1733 var snapshot bytes.Buffer 1734 io.Copy(&snapshot, ringBuffer) 1735 err = &smithy.DeserializationError{ 1736 Err: fmt.Errorf("failed to decode response body, %w", err), 1737 Snapshot: snapshot.Bytes(), 1738 } 1739 return out, metadata, err 1740 } 1741 1742 err = awsAwsjson11_deserializeOpDocumentGetThirdPartyJobDetailsOutput(&output, shape) 1743 if err != nil { 1744 var snapshot bytes.Buffer 1745 io.Copy(&snapshot, ringBuffer) 1746 err = &smithy.DeserializationError{ 1747 Err: fmt.Errorf("failed to decode response body, %w", err), 1748 Snapshot: snapshot.Bytes(), 1749 } 1750 return out, metadata, err 1751 } 1752 1753 return out, metadata, err 1754} 1755 1756func awsAwsjson11_deserializeOpErrorGetThirdPartyJobDetails(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1757 var errorBuffer bytes.Buffer 1758 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1759 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1760 } 1761 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1762 1763 errorCode := "UnknownError" 1764 errorMessage := errorCode 1765 1766 code := response.Header.Get("X-Amzn-ErrorType") 1767 if len(code) != 0 { 1768 errorCode = restjson.SanitizeErrorCode(code) 1769 } 1770 1771 var buff [1024]byte 1772 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1773 1774 body := io.TeeReader(errorBody, ringBuffer) 1775 decoder := json.NewDecoder(body) 1776 decoder.UseNumber() 1777 code, message, err := restjson.GetErrorInfo(decoder) 1778 if err != nil { 1779 var snapshot bytes.Buffer 1780 io.Copy(&snapshot, ringBuffer) 1781 err = &smithy.DeserializationError{ 1782 Err: fmt.Errorf("failed to decode response body, %w", err), 1783 Snapshot: snapshot.Bytes(), 1784 } 1785 return err 1786 } 1787 1788 errorBody.Seek(0, io.SeekStart) 1789 if len(code) != 0 { 1790 errorCode = restjson.SanitizeErrorCode(code) 1791 } 1792 if len(message) != 0 { 1793 errorMessage = message 1794 } 1795 1796 switch { 1797 case strings.EqualFold("InvalidClientTokenException", errorCode): 1798 return awsAwsjson11_deserializeErrorInvalidClientTokenException(response, errorBody) 1799 1800 case strings.EqualFold("InvalidJobException", errorCode): 1801 return awsAwsjson11_deserializeErrorInvalidJobException(response, errorBody) 1802 1803 case strings.EqualFold("JobNotFoundException", errorCode): 1804 return awsAwsjson11_deserializeErrorJobNotFoundException(response, errorBody) 1805 1806 case strings.EqualFold("ValidationException", errorCode): 1807 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1808 1809 default: 1810 genericError := &smithy.GenericAPIError{ 1811 Code: errorCode, 1812 Message: errorMessage, 1813 } 1814 return genericError 1815 1816 } 1817} 1818 1819type awsAwsjson11_deserializeOpListActionExecutions struct { 1820} 1821 1822func (*awsAwsjson11_deserializeOpListActionExecutions) ID() string { 1823 return "OperationDeserializer" 1824} 1825 1826func (m *awsAwsjson11_deserializeOpListActionExecutions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1827 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1828) { 1829 out, metadata, err = next.HandleDeserialize(ctx, in) 1830 if err != nil { 1831 return out, metadata, err 1832 } 1833 1834 response, ok := out.RawResponse.(*smithyhttp.Response) 1835 if !ok { 1836 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1837 } 1838 1839 if response.StatusCode < 200 || response.StatusCode >= 300 { 1840 return out, metadata, awsAwsjson11_deserializeOpErrorListActionExecutions(response, &metadata) 1841 } 1842 output := &ListActionExecutionsOutput{} 1843 out.Result = output 1844 1845 var buff [1024]byte 1846 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1847 1848 body := io.TeeReader(response.Body, ringBuffer) 1849 decoder := json.NewDecoder(body) 1850 decoder.UseNumber() 1851 var shape interface{} 1852 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1853 var snapshot bytes.Buffer 1854 io.Copy(&snapshot, ringBuffer) 1855 err = &smithy.DeserializationError{ 1856 Err: fmt.Errorf("failed to decode response body, %w", err), 1857 Snapshot: snapshot.Bytes(), 1858 } 1859 return out, metadata, err 1860 } 1861 1862 err = awsAwsjson11_deserializeOpDocumentListActionExecutionsOutput(&output, shape) 1863 if err != nil { 1864 var snapshot bytes.Buffer 1865 io.Copy(&snapshot, ringBuffer) 1866 err = &smithy.DeserializationError{ 1867 Err: fmt.Errorf("failed to decode response body, %w", err), 1868 Snapshot: snapshot.Bytes(), 1869 } 1870 return out, metadata, err 1871 } 1872 1873 return out, metadata, err 1874} 1875 1876func awsAwsjson11_deserializeOpErrorListActionExecutions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1877 var errorBuffer bytes.Buffer 1878 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1879 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1880 } 1881 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1882 1883 errorCode := "UnknownError" 1884 errorMessage := errorCode 1885 1886 code := response.Header.Get("X-Amzn-ErrorType") 1887 if len(code) != 0 { 1888 errorCode = restjson.SanitizeErrorCode(code) 1889 } 1890 1891 var buff [1024]byte 1892 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1893 1894 body := io.TeeReader(errorBody, ringBuffer) 1895 decoder := json.NewDecoder(body) 1896 decoder.UseNumber() 1897 code, message, err := restjson.GetErrorInfo(decoder) 1898 if err != nil { 1899 var snapshot bytes.Buffer 1900 io.Copy(&snapshot, ringBuffer) 1901 err = &smithy.DeserializationError{ 1902 Err: fmt.Errorf("failed to decode response body, %w", err), 1903 Snapshot: snapshot.Bytes(), 1904 } 1905 return err 1906 } 1907 1908 errorBody.Seek(0, io.SeekStart) 1909 if len(code) != 0 { 1910 errorCode = restjson.SanitizeErrorCode(code) 1911 } 1912 if len(message) != 0 { 1913 errorMessage = message 1914 } 1915 1916 switch { 1917 case strings.EqualFold("InvalidNextTokenException", errorCode): 1918 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 1919 1920 case strings.EqualFold("PipelineExecutionNotFoundException", errorCode): 1921 return awsAwsjson11_deserializeErrorPipelineExecutionNotFoundException(response, errorBody) 1922 1923 case strings.EqualFold("PipelineNotFoundException", errorCode): 1924 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 1925 1926 case strings.EqualFold("ValidationException", errorCode): 1927 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1928 1929 default: 1930 genericError := &smithy.GenericAPIError{ 1931 Code: errorCode, 1932 Message: errorMessage, 1933 } 1934 return genericError 1935 1936 } 1937} 1938 1939type awsAwsjson11_deserializeOpListActionTypes struct { 1940} 1941 1942func (*awsAwsjson11_deserializeOpListActionTypes) ID() string { 1943 return "OperationDeserializer" 1944} 1945 1946func (m *awsAwsjson11_deserializeOpListActionTypes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1947 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1948) { 1949 out, metadata, err = next.HandleDeserialize(ctx, in) 1950 if err != nil { 1951 return out, metadata, err 1952 } 1953 1954 response, ok := out.RawResponse.(*smithyhttp.Response) 1955 if !ok { 1956 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1957 } 1958 1959 if response.StatusCode < 200 || response.StatusCode >= 300 { 1960 return out, metadata, awsAwsjson11_deserializeOpErrorListActionTypes(response, &metadata) 1961 } 1962 output := &ListActionTypesOutput{} 1963 out.Result = output 1964 1965 var buff [1024]byte 1966 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1967 1968 body := io.TeeReader(response.Body, ringBuffer) 1969 decoder := json.NewDecoder(body) 1970 decoder.UseNumber() 1971 var shape interface{} 1972 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1973 var snapshot bytes.Buffer 1974 io.Copy(&snapshot, ringBuffer) 1975 err = &smithy.DeserializationError{ 1976 Err: fmt.Errorf("failed to decode response body, %w", err), 1977 Snapshot: snapshot.Bytes(), 1978 } 1979 return out, metadata, err 1980 } 1981 1982 err = awsAwsjson11_deserializeOpDocumentListActionTypesOutput(&output, shape) 1983 if err != nil { 1984 var snapshot bytes.Buffer 1985 io.Copy(&snapshot, ringBuffer) 1986 err = &smithy.DeserializationError{ 1987 Err: fmt.Errorf("failed to decode response body, %w", err), 1988 Snapshot: snapshot.Bytes(), 1989 } 1990 return out, metadata, err 1991 } 1992 1993 return out, metadata, err 1994} 1995 1996func awsAwsjson11_deserializeOpErrorListActionTypes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1997 var errorBuffer bytes.Buffer 1998 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1999 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2000 } 2001 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2002 2003 errorCode := "UnknownError" 2004 errorMessage := errorCode 2005 2006 code := response.Header.Get("X-Amzn-ErrorType") 2007 if len(code) != 0 { 2008 errorCode = restjson.SanitizeErrorCode(code) 2009 } 2010 2011 var buff [1024]byte 2012 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2013 2014 body := io.TeeReader(errorBody, ringBuffer) 2015 decoder := json.NewDecoder(body) 2016 decoder.UseNumber() 2017 code, message, err := restjson.GetErrorInfo(decoder) 2018 if err != nil { 2019 var snapshot bytes.Buffer 2020 io.Copy(&snapshot, ringBuffer) 2021 err = &smithy.DeserializationError{ 2022 Err: fmt.Errorf("failed to decode response body, %w", err), 2023 Snapshot: snapshot.Bytes(), 2024 } 2025 return err 2026 } 2027 2028 errorBody.Seek(0, io.SeekStart) 2029 if len(code) != 0 { 2030 errorCode = restjson.SanitizeErrorCode(code) 2031 } 2032 if len(message) != 0 { 2033 errorMessage = message 2034 } 2035 2036 switch { 2037 case strings.EqualFold("InvalidNextTokenException", errorCode): 2038 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 2039 2040 case strings.EqualFold("ValidationException", errorCode): 2041 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2042 2043 default: 2044 genericError := &smithy.GenericAPIError{ 2045 Code: errorCode, 2046 Message: errorMessage, 2047 } 2048 return genericError 2049 2050 } 2051} 2052 2053type awsAwsjson11_deserializeOpListPipelineExecutions struct { 2054} 2055 2056func (*awsAwsjson11_deserializeOpListPipelineExecutions) ID() string { 2057 return "OperationDeserializer" 2058} 2059 2060func (m *awsAwsjson11_deserializeOpListPipelineExecutions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2061 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2062) { 2063 out, metadata, err = next.HandleDeserialize(ctx, in) 2064 if err != nil { 2065 return out, metadata, err 2066 } 2067 2068 response, ok := out.RawResponse.(*smithyhttp.Response) 2069 if !ok { 2070 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2071 } 2072 2073 if response.StatusCode < 200 || response.StatusCode >= 300 { 2074 return out, metadata, awsAwsjson11_deserializeOpErrorListPipelineExecutions(response, &metadata) 2075 } 2076 output := &ListPipelineExecutionsOutput{} 2077 out.Result = output 2078 2079 var buff [1024]byte 2080 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2081 2082 body := io.TeeReader(response.Body, ringBuffer) 2083 decoder := json.NewDecoder(body) 2084 decoder.UseNumber() 2085 var shape interface{} 2086 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2087 var snapshot bytes.Buffer 2088 io.Copy(&snapshot, ringBuffer) 2089 err = &smithy.DeserializationError{ 2090 Err: fmt.Errorf("failed to decode response body, %w", err), 2091 Snapshot: snapshot.Bytes(), 2092 } 2093 return out, metadata, err 2094 } 2095 2096 err = awsAwsjson11_deserializeOpDocumentListPipelineExecutionsOutput(&output, shape) 2097 if err != nil { 2098 var snapshot bytes.Buffer 2099 io.Copy(&snapshot, ringBuffer) 2100 err = &smithy.DeserializationError{ 2101 Err: fmt.Errorf("failed to decode response body, %w", err), 2102 Snapshot: snapshot.Bytes(), 2103 } 2104 return out, metadata, err 2105 } 2106 2107 return out, metadata, err 2108} 2109 2110func awsAwsjson11_deserializeOpErrorListPipelineExecutions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2111 var errorBuffer bytes.Buffer 2112 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2113 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2114 } 2115 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2116 2117 errorCode := "UnknownError" 2118 errorMessage := errorCode 2119 2120 code := response.Header.Get("X-Amzn-ErrorType") 2121 if len(code) != 0 { 2122 errorCode = restjson.SanitizeErrorCode(code) 2123 } 2124 2125 var buff [1024]byte 2126 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2127 2128 body := io.TeeReader(errorBody, ringBuffer) 2129 decoder := json.NewDecoder(body) 2130 decoder.UseNumber() 2131 code, message, err := restjson.GetErrorInfo(decoder) 2132 if err != nil { 2133 var snapshot bytes.Buffer 2134 io.Copy(&snapshot, ringBuffer) 2135 err = &smithy.DeserializationError{ 2136 Err: fmt.Errorf("failed to decode response body, %w", err), 2137 Snapshot: snapshot.Bytes(), 2138 } 2139 return err 2140 } 2141 2142 errorBody.Seek(0, io.SeekStart) 2143 if len(code) != 0 { 2144 errorCode = restjson.SanitizeErrorCode(code) 2145 } 2146 if len(message) != 0 { 2147 errorMessage = message 2148 } 2149 2150 switch { 2151 case strings.EqualFold("InvalidNextTokenException", errorCode): 2152 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 2153 2154 case strings.EqualFold("PipelineNotFoundException", errorCode): 2155 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 2156 2157 case strings.EqualFold("ValidationException", errorCode): 2158 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2159 2160 default: 2161 genericError := &smithy.GenericAPIError{ 2162 Code: errorCode, 2163 Message: errorMessage, 2164 } 2165 return genericError 2166 2167 } 2168} 2169 2170type awsAwsjson11_deserializeOpListPipelines struct { 2171} 2172 2173func (*awsAwsjson11_deserializeOpListPipelines) ID() string { 2174 return "OperationDeserializer" 2175} 2176 2177func (m *awsAwsjson11_deserializeOpListPipelines) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2178 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2179) { 2180 out, metadata, err = next.HandleDeserialize(ctx, in) 2181 if err != nil { 2182 return out, metadata, err 2183 } 2184 2185 response, ok := out.RawResponse.(*smithyhttp.Response) 2186 if !ok { 2187 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2188 } 2189 2190 if response.StatusCode < 200 || response.StatusCode >= 300 { 2191 return out, metadata, awsAwsjson11_deserializeOpErrorListPipelines(response, &metadata) 2192 } 2193 output := &ListPipelinesOutput{} 2194 out.Result = output 2195 2196 var buff [1024]byte 2197 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2198 2199 body := io.TeeReader(response.Body, ringBuffer) 2200 decoder := json.NewDecoder(body) 2201 decoder.UseNumber() 2202 var shape interface{} 2203 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2204 var snapshot bytes.Buffer 2205 io.Copy(&snapshot, ringBuffer) 2206 err = &smithy.DeserializationError{ 2207 Err: fmt.Errorf("failed to decode response body, %w", err), 2208 Snapshot: snapshot.Bytes(), 2209 } 2210 return out, metadata, err 2211 } 2212 2213 err = awsAwsjson11_deserializeOpDocumentListPipelinesOutput(&output, shape) 2214 if err != nil { 2215 var snapshot bytes.Buffer 2216 io.Copy(&snapshot, ringBuffer) 2217 err = &smithy.DeserializationError{ 2218 Err: fmt.Errorf("failed to decode response body, %w", err), 2219 Snapshot: snapshot.Bytes(), 2220 } 2221 return out, metadata, err 2222 } 2223 2224 return out, metadata, err 2225} 2226 2227func awsAwsjson11_deserializeOpErrorListPipelines(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2228 var errorBuffer bytes.Buffer 2229 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2230 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2231 } 2232 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2233 2234 errorCode := "UnknownError" 2235 errorMessage := errorCode 2236 2237 code := response.Header.Get("X-Amzn-ErrorType") 2238 if len(code) != 0 { 2239 errorCode = restjson.SanitizeErrorCode(code) 2240 } 2241 2242 var buff [1024]byte 2243 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2244 2245 body := io.TeeReader(errorBody, ringBuffer) 2246 decoder := json.NewDecoder(body) 2247 decoder.UseNumber() 2248 code, message, err := restjson.GetErrorInfo(decoder) 2249 if err != nil { 2250 var snapshot bytes.Buffer 2251 io.Copy(&snapshot, ringBuffer) 2252 err = &smithy.DeserializationError{ 2253 Err: fmt.Errorf("failed to decode response body, %w", err), 2254 Snapshot: snapshot.Bytes(), 2255 } 2256 return err 2257 } 2258 2259 errorBody.Seek(0, io.SeekStart) 2260 if len(code) != 0 { 2261 errorCode = restjson.SanitizeErrorCode(code) 2262 } 2263 if len(message) != 0 { 2264 errorMessage = message 2265 } 2266 2267 switch { 2268 case strings.EqualFold("InvalidNextTokenException", errorCode): 2269 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 2270 2271 case strings.EqualFold("ValidationException", errorCode): 2272 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2273 2274 default: 2275 genericError := &smithy.GenericAPIError{ 2276 Code: errorCode, 2277 Message: errorMessage, 2278 } 2279 return genericError 2280 2281 } 2282} 2283 2284type awsAwsjson11_deserializeOpListTagsForResource struct { 2285} 2286 2287func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string { 2288 return "OperationDeserializer" 2289} 2290 2291func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2292 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2293) { 2294 out, metadata, err = next.HandleDeserialize(ctx, in) 2295 if err != nil { 2296 return out, metadata, err 2297 } 2298 2299 response, ok := out.RawResponse.(*smithyhttp.Response) 2300 if !ok { 2301 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2302 } 2303 2304 if response.StatusCode < 200 || response.StatusCode >= 300 { 2305 return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata) 2306 } 2307 output := &ListTagsForResourceOutput{} 2308 out.Result = output 2309 2310 var buff [1024]byte 2311 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2312 2313 body := io.TeeReader(response.Body, ringBuffer) 2314 decoder := json.NewDecoder(body) 2315 decoder.UseNumber() 2316 var shape interface{} 2317 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2318 var snapshot bytes.Buffer 2319 io.Copy(&snapshot, ringBuffer) 2320 err = &smithy.DeserializationError{ 2321 Err: fmt.Errorf("failed to decode response body, %w", err), 2322 Snapshot: snapshot.Bytes(), 2323 } 2324 return out, metadata, err 2325 } 2326 2327 err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 2328 if err != nil { 2329 var snapshot bytes.Buffer 2330 io.Copy(&snapshot, ringBuffer) 2331 err = &smithy.DeserializationError{ 2332 Err: fmt.Errorf("failed to decode response body, %w", err), 2333 Snapshot: snapshot.Bytes(), 2334 } 2335 return out, metadata, err 2336 } 2337 2338 return out, metadata, err 2339} 2340 2341func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2342 var errorBuffer bytes.Buffer 2343 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2344 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2345 } 2346 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2347 2348 errorCode := "UnknownError" 2349 errorMessage := errorCode 2350 2351 code := response.Header.Get("X-Amzn-ErrorType") 2352 if len(code) != 0 { 2353 errorCode = restjson.SanitizeErrorCode(code) 2354 } 2355 2356 var buff [1024]byte 2357 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2358 2359 body := io.TeeReader(errorBody, ringBuffer) 2360 decoder := json.NewDecoder(body) 2361 decoder.UseNumber() 2362 code, message, err := restjson.GetErrorInfo(decoder) 2363 if err != nil { 2364 var snapshot bytes.Buffer 2365 io.Copy(&snapshot, ringBuffer) 2366 err = &smithy.DeserializationError{ 2367 Err: fmt.Errorf("failed to decode response body, %w", err), 2368 Snapshot: snapshot.Bytes(), 2369 } 2370 return err 2371 } 2372 2373 errorBody.Seek(0, io.SeekStart) 2374 if len(code) != 0 { 2375 errorCode = restjson.SanitizeErrorCode(code) 2376 } 2377 if len(message) != 0 { 2378 errorMessage = message 2379 } 2380 2381 switch { 2382 case strings.EqualFold("InvalidArnException", errorCode): 2383 return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) 2384 2385 case strings.EqualFold("InvalidNextTokenException", errorCode): 2386 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 2387 2388 case strings.EqualFold("ResourceNotFoundException", errorCode): 2389 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2390 2391 case strings.EqualFold("ValidationException", errorCode): 2392 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2393 2394 default: 2395 genericError := &smithy.GenericAPIError{ 2396 Code: errorCode, 2397 Message: errorMessage, 2398 } 2399 return genericError 2400 2401 } 2402} 2403 2404type awsAwsjson11_deserializeOpListWebhooks struct { 2405} 2406 2407func (*awsAwsjson11_deserializeOpListWebhooks) ID() string { 2408 return "OperationDeserializer" 2409} 2410 2411func (m *awsAwsjson11_deserializeOpListWebhooks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2412 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2413) { 2414 out, metadata, err = next.HandleDeserialize(ctx, in) 2415 if err != nil { 2416 return out, metadata, err 2417 } 2418 2419 response, ok := out.RawResponse.(*smithyhttp.Response) 2420 if !ok { 2421 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2422 } 2423 2424 if response.StatusCode < 200 || response.StatusCode >= 300 { 2425 return out, metadata, awsAwsjson11_deserializeOpErrorListWebhooks(response, &metadata) 2426 } 2427 output := &ListWebhooksOutput{} 2428 out.Result = output 2429 2430 var buff [1024]byte 2431 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2432 2433 body := io.TeeReader(response.Body, ringBuffer) 2434 decoder := json.NewDecoder(body) 2435 decoder.UseNumber() 2436 var shape interface{} 2437 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2438 var snapshot bytes.Buffer 2439 io.Copy(&snapshot, ringBuffer) 2440 err = &smithy.DeserializationError{ 2441 Err: fmt.Errorf("failed to decode response body, %w", err), 2442 Snapshot: snapshot.Bytes(), 2443 } 2444 return out, metadata, err 2445 } 2446 2447 err = awsAwsjson11_deserializeOpDocumentListWebhooksOutput(&output, shape) 2448 if err != nil { 2449 var snapshot bytes.Buffer 2450 io.Copy(&snapshot, ringBuffer) 2451 err = &smithy.DeserializationError{ 2452 Err: fmt.Errorf("failed to decode response body, %w", err), 2453 Snapshot: snapshot.Bytes(), 2454 } 2455 return out, metadata, err 2456 } 2457 2458 return out, metadata, err 2459} 2460 2461func awsAwsjson11_deserializeOpErrorListWebhooks(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2462 var errorBuffer bytes.Buffer 2463 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2464 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2465 } 2466 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2467 2468 errorCode := "UnknownError" 2469 errorMessage := errorCode 2470 2471 code := response.Header.Get("X-Amzn-ErrorType") 2472 if len(code) != 0 { 2473 errorCode = restjson.SanitizeErrorCode(code) 2474 } 2475 2476 var buff [1024]byte 2477 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2478 2479 body := io.TeeReader(errorBody, ringBuffer) 2480 decoder := json.NewDecoder(body) 2481 decoder.UseNumber() 2482 code, message, err := restjson.GetErrorInfo(decoder) 2483 if err != nil { 2484 var snapshot bytes.Buffer 2485 io.Copy(&snapshot, ringBuffer) 2486 err = &smithy.DeserializationError{ 2487 Err: fmt.Errorf("failed to decode response body, %w", err), 2488 Snapshot: snapshot.Bytes(), 2489 } 2490 return err 2491 } 2492 2493 errorBody.Seek(0, io.SeekStart) 2494 if len(code) != 0 { 2495 errorCode = restjson.SanitizeErrorCode(code) 2496 } 2497 if len(message) != 0 { 2498 errorMessage = message 2499 } 2500 2501 switch { 2502 case strings.EqualFold("InvalidNextTokenException", errorCode): 2503 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 2504 2505 case strings.EqualFold("ValidationException", errorCode): 2506 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2507 2508 default: 2509 genericError := &smithy.GenericAPIError{ 2510 Code: errorCode, 2511 Message: errorMessage, 2512 } 2513 return genericError 2514 2515 } 2516} 2517 2518type awsAwsjson11_deserializeOpPollForJobs struct { 2519} 2520 2521func (*awsAwsjson11_deserializeOpPollForJobs) ID() string { 2522 return "OperationDeserializer" 2523} 2524 2525func (m *awsAwsjson11_deserializeOpPollForJobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2526 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2527) { 2528 out, metadata, err = next.HandleDeserialize(ctx, in) 2529 if err != nil { 2530 return out, metadata, err 2531 } 2532 2533 response, ok := out.RawResponse.(*smithyhttp.Response) 2534 if !ok { 2535 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2536 } 2537 2538 if response.StatusCode < 200 || response.StatusCode >= 300 { 2539 return out, metadata, awsAwsjson11_deserializeOpErrorPollForJobs(response, &metadata) 2540 } 2541 output := &PollForJobsOutput{} 2542 out.Result = output 2543 2544 var buff [1024]byte 2545 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2546 2547 body := io.TeeReader(response.Body, ringBuffer) 2548 decoder := json.NewDecoder(body) 2549 decoder.UseNumber() 2550 var shape interface{} 2551 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2552 var snapshot bytes.Buffer 2553 io.Copy(&snapshot, ringBuffer) 2554 err = &smithy.DeserializationError{ 2555 Err: fmt.Errorf("failed to decode response body, %w", err), 2556 Snapshot: snapshot.Bytes(), 2557 } 2558 return out, metadata, err 2559 } 2560 2561 err = awsAwsjson11_deserializeOpDocumentPollForJobsOutput(&output, shape) 2562 if err != nil { 2563 var snapshot bytes.Buffer 2564 io.Copy(&snapshot, ringBuffer) 2565 err = &smithy.DeserializationError{ 2566 Err: fmt.Errorf("failed to decode response body, %w", err), 2567 Snapshot: snapshot.Bytes(), 2568 } 2569 return out, metadata, err 2570 } 2571 2572 return out, metadata, err 2573} 2574 2575func awsAwsjson11_deserializeOpErrorPollForJobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2576 var errorBuffer bytes.Buffer 2577 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2578 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2579 } 2580 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2581 2582 errorCode := "UnknownError" 2583 errorMessage := errorCode 2584 2585 code := response.Header.Get("X-Amzn-ErrorType") 2586 if len(code) != 0 { 2587 errorCode = restjson.SanitizeErrorCode(code) 2588 } 2589 2590 var buff [1024]byte 2591 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2592 2593 body := io.TeeReader(errorBody, ringBuffer) 2594 decoder := json.NewDecoder(body) 2595 decoder.UseNumber() 2596 code, message, err := restjson.GetErrorInfo(decoder) 2597 if err != nil { 2598 var snapshot bytes.Buffer 2599 io.Copy(&snapshot, ringBuffer) 2600 err = &smithy.DeserializationError{ 2601 Err: fmt.Errorf("failed to decode response body, %w", err), 2602 Snapshot: snapshot.Bytes(), 2603 } 2604 return err 2605 } 2606 2607 errorBody.Seek(0, io.SeekStart) 2608 if len(code) != 0 { 2609 errorCode = restjson.SanitizeErrorCode(code) 2610 } 2611 if len(message) != 0 { 2612 errorMessage = message 2613 } 2614 2615 switch { 2616 case strings.EqualFold("ActionTypeNotFoundException", errorCode): 2617 return awsAwsjson11_deserializeErrorActionTypeNotFoundException(response, errorBody) 2618 2619 case strings.EqualFold("ValidationException", errorCode): 2620 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2621 2622 default: 2623 genericError := &smithy.GenericAPIError{ 2624 Code: errorCode, 2625 Message: errorMessage, 2626 } 2627 return genericError 2628 2629 } 2630} 2631 2632type awsAwsjson11_deserializeOpPollForThirdPartyJobs struct { 2633} 2634 2635func (*awsAwsjson11_deserializeOpPollForThirdPartyJobs) ID() string { 2636 return "OperationDeserializer" 2637} 2638 2639func (m *awsAwsjson11_deserializeOpPollForThirdPartyJobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2640 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2641) { 2642 out, metadata, err = next.HandleDeserialize(ctx, in) 2643 if err != nil { 2644 return out, metadata, err 2645 } 2646 2647 response, ok := out.RawResponse.(*smithyhttp.Response) 2648 if !ok { 2649 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2650 } 2651 2652 if response.StatusCode < 200 || response.StatusCode >= 300 { 2653 return out, metadata, awsAwsjson11_deserializeOpErrorPollForThirdPartyJobs(response, &metadata) 2654 } 2655 output := &PollForThirdPartyJobsOutput{} 2656 out.Result = output 2657 2658 var buff [1024]byte 2659 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2660 2661 body := io.TeeReader(response.Body, ringBuffer) 2662 decoder := json.NewDecoder(body) 2663 decoder.UseNumber() 2664 var shape interface{} 2665 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2666 var snapshot bytes.Buffer 2667 io.Copy(&snapshot, ringBuffer) 2668 err = &smithy.DeserializationError{ 2669 Err: fmt.Errorf("failed to decode response body, %w", err), 2670 Snapshot: snapshot.Bytes(), 2671 } 2672 return out, metadata, err 2673 } 2674 2675 err = awsAwsjson11_deserializeOpDocumentPollForThirdPartyJobsOutput(&output, shape) 2676 if err != nil { 2677 var snapshot bytes.Buffer 2678 io.Copy(&snapshot, ringBuffer) 2679 err = &smithy.DeserializationError{ 2680 Err: fmt.Errorf("failed to decode response body, %w", err), 2681 Snapshot: snapshot.Bytes(), 2682 } 2683 return out, metadata, err 2684 } 2685 2686 return out, metadata, err 2687} 2688 2689func awsAwsjson11_deserializeOpErrorPollForThirdPartyJobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2690 var errorBuffer bytes.Buffer 2691 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2692 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2693 } 2694 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2695 2696 errorCode := "UnknownError" 2697 errorMessage := errorCode 2698 2699 code := response.Header.Get("X-Amzn-ErrorType") 2700 if len(code) != 0 { 2701 errorCode = restjson.SanitizeErrorCode(code) 2702 } 2703 2704 var buff [1024]byte 2705 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2706 2707 body := io.TeeReader(errorBody, ringBuffer) 2708 decoder := json.NewDecoder(body) 2709 decoder.UseNumber() 2710 code, message, err := restjson.GetErrorInfo(decoder) 2711 if err != nil { 2712 var snapshot bytes.Buffer 2713 io.Copy(&snapshot, ringBuffer) 2714 err = &smithy.DeserializationError{ 2715 Err: fmt.Errorf("failed to decode response body, %w", err), 2716 Snapshot: snapshot.Bytes(), 2717 } 2718 return err 2719 } 2720 2721 errorBody.Seek(0, io.SeekStart) 2722 if len(code) != 0 { 2723 errorCode = restjson.SanitizeErrorCode(code) 2724 } 2725 if len(message) != 0 { 2726 errorMessage = message 2727 } 2728 2729 switch { 2730 case strings.EqualFold("ActionTypeNotFoundException", errorCode): 2731 return awsAwsjson11_deserializeErrorActionTypeNotFoundException(response, errorBody) 2732 2733 case strings.EqualFold("ValidationException", errorCode): 2734 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2735 2736 default: 2737 genericError := &smithy.GenericAPIError{ 2738 Code: errorCode, 2739 Message: errorMessage, 2740 } 2741 return genericError 2742 2743 } 2744} 2745 2746type awsAwsjson11_deserializeOpPutActionRevision struct { 2747} 2748 2749func (*awsAwsjson11_deserializeOpPutActionRevision) ID() string { 2750 return "OperationDeserializer" 2751} 2752 2753func (m *awsAwsjson11_deserializeOpPutActionRevision) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2754 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2755) { 2756 out, metadata, err = next.HandleDeserialize(ctx, in) 2757 if err != nil { 2758 return out, metadata, err 2759 } 2760 2761 response, ok := out.RawResponse.(*smithyhttp.Response) 2762 if !ok { 2763 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2764 } 2765 2766 if response.StatusCode < 200 || response.StatusCode >= 300 { 2767 return out, metadata, awsAwsjson11_deserializeOpErrorPutActionRevision(response, &metadata) 2768 } 2769 output := &PutActionRevisionOutput{} 2770 out.Result = output 2771 2772 var buff [1024]byte 2773 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2774 2775 body := io.TeeReader(response.Body, ringBuffer) 2776 decoder := json.NewDecoder(body) 2777 decoder.UseNumber() 2778 var shape interface{} 2779 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2780 var snapshot bytes.Buffer 2781 io.Copy(&snapshot, ringBuffer) 2782 err = &smithy.DeserializationError{ 2783 Err: fmt.Errorf("failed to decode response body, %w", err), 2784 Snapshot: snapshot.Bytes(), 2785 } 2786 return out, metadata, err 2787 } 2788 2789 err = awsAwsjson11_deserializeOpDocumentPutActionRevisionOutput(&output, shape) 2790 if err != nil { 2791 var snapshot bytes.Buffer 2792 io.Copy(&snapshot, ringBuffer) 2793 err = &smithy.DeserializationError{ 2794 Err: fmt.Errorf("failed to decode response body, %w", err), 2795 Snapshot: snapshot.Bytes(), 2796 } 2797 return out, metadata, err 2798 } 2799 2800 return out, metadata, err 2801} 2802 2803func awsAwsjson11_deserializeOpErrorPutActionRevision(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2804 var errorBuffer bytes.Buffer 2805 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2806 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2807 } 2808 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2809 2810 errorCode := "UnknownError" 2811 errorMessage := errorCode 2812 2813 code := response.Header.Get("X-Amzn-ErrorType") 2814 if len(code) != 0 { 2815 errorCode = restjson.SanitizeErrorCode(code) 2816 } 2817 2818 var buff [1024]byte 2819 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2820 2821 body := io.TeeReader(errorBody, ringBuffer) 2822 decoder := json.NewDecoder(body) 2823 decoder.UseNumber() 2824 code, message, err := restjson.GetErrorInfo(decoder) 2825 if err != nil { 2826 var snapshot bytes.Buffer 2827 io.Copy(&snapshot, ringBuffer) 2828 err = &smithy.DeserializationError{ 2829 Err: fmt.Errorf("failed to decode response body, %w", err), 2830 Snapshot: snapshot.Bytes(), 2831 } 2832 return err 2833 } 2834 2835 errorBody.Seek(0, io.SeekStart) 2836 if len(code) != 0 { 2837 errorCode = restjson.SanitizeErrorCode(code) 2838 } 2839 if len(message) != 0 { 2840 errorMessage = message 2841 } 2842 2843 switch { 2844 case strings.EqualFold("ActionNotFoundException", errorCode): 2845 return awsAwsjson11_deserializeErrorActionNotFoundException(response, errorBody) 2846 2847 case strings.EqualFold("PipelineNotFoundException", errorCode): 2848 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 2849 2850 case strings.EqualFold("StageNotFoundException", errorCode): 2851 return awsAwsjson11_deserializeErrorStageNotFoundException(response, errorBody) 2852 2853 case strings.EqualFold("ValidationException", errorCode): 2854 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2855 2856 default: 2857 genericError := &smithy.GenericAPIError{ 2858 Code: errorCode, 2859 Message: errorMessage, 2860 } 2861 return genericError 2862 2863 } 2864} 2865 2866type awsAwsjson11_deserializeOpPutApprovalResult struct { 2867} 2868 2869func (*awsAwsjson11_deserializeOpPutApprovalResult) ID() string { 2870 return "OperationDeserializer" 2871} 2872 2873func (m *awsAwsjson11_deserializeOpPutApprovalResult) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2874 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2875) { 2876 out, metadata, err = next.HandleDeserialize(ctx, in) 2877 if err != nil { 2878 return out, metadata, err 2879 } 2880 2881 response, ok := out.RawResponse.(*smithyhttp.Response) 2882 if !ok { 2883 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2884 } 2885 2886 if response.StatusCode < 200 || response.StatusCode >= 300 { 2887 return out, metadata, awsAwsjson11_deserializeOpErrorPutApprovalResult(response, &metadata) 2888 } 2889 output := &PutApprovalResultOutput{} 2890 out.Result = output 2891 2892 var buff [1024]byte 2893 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2894 2895 body := io.TeeReader(response.Body, ringBuffer) 2896 decoder := json.NewDecoder(body) 2897 decoder.UseNumber() 2898 var shape interface{} 2899 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2900 var snapshot bytes.Buffer 2901 io.Copy(&snapshot, ringBuffer) 2902 err = &smithy.DeserializationError{ 2903 Err: fmt.Errorf("failed to decode response body, %w", err), 2904 Snapshot: snapshot.Bytes(), 2905 } 2906 return out, metadata, err 2907 } 2908 2909 err = awsAwsjson11_deserializeOpDocumentPutApprovalResultOutput(&output, shape) 2910 if err != nil { 2911 var snapshot bytes.Buffer 2912 io.Copy(&snapshot, ringBuffer) 2913 err = &smithy.DeserializationError{ 2914 Err: fmt.Errorf("failed to decode response body, %w", err), 2915 Snapshot: snapshot.Bytes(), 2916 } 2917 return out, metadata, err 2918 } 2919 2920 return out, metadata, err 2921} 2922 2923func awsAwsjson11_deserializeOpErrorPutApprovalResult(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2924 var errorBuffer bytes.Buffer 2925 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2926 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2927 } 2928 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2929 2930 errorCode := "UnknownError" 2931 errorMessage := errorCode 2932 2933 code := response.Header.Get("X-Amzn-ErrorType") 2934 if len(code) != 0 { 2935 errorCode = restjson.SanitizeErrorCode(code) 2936 } 2937 2938 var buff [1024]byte 2939 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2940 2941 body := io.TeeReader(errorBody, ringBuffer) 2942 decoder := json.NewDecoder(body) 2943 decoder.UseNumber() 2944 code, message, err := restjson.GetErrorInfo(decoder) 2945 if err != nil { 2946 var snapshot bytes.Buffer 2947 io.Copy(&snapshot, ringBuffer) 2948 err = &smithy.DeserializationError{ 2949 Err: fmt.Errorf("failed to decode response body, %w", err), 2950 Snapshot: snapshot.Bytes(), 2951 } 2952 return err 2953 } 2954 2955 errorBody.Seek(0, io.SeekStart) 2956 if len(code) != 0 { 2957 errorCode = restjson.SanitizeErrorCode(code) 2958 } 2959 if len(message) != 0 { 2960 errorMessage = message 2961 } 2962 2963 switch { 2964 case strings.EqualFold("ActionNotFoundException", errorCode): 2965 return awsAwsjson11_deserializeErrorActionNotFoundException(response, errorBody) 2966 2967 case strings.EqualFold("ApprovalAlreadyCompletedException", errorCode): 2968 return awsAwsjson11_deserializeErrorApprovalAlreadyCompletedException(response, errorBody) 2969 2970 case strings.EqualFold("InvalidApprovalTokenException", errorCode): 2971 return awsAwsjson11_deserializeErrorInvalidApprovalTokenException(response, errorBody) 2972 2973 case strings.EqualFold("PipelineNotFoundException", errorCode): 2974 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 2975 2976 case strings.EqualFold("StageNotFoundException", errorCode): 2977 return awsAwsjson11_deserializeErrorStageNotFoundException(response, errorBody) 2978 2979 case strings.EqualFold("ValidationException", errorCode): 2980 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2981 2982 default: 2983 genericError := &smithy.GenericAPIError{ 2984 Code: errorCode, 2985 Message: errorMessage, 2986 } 2987 return genericError 2988 2989 } 2990} 2991 2992type awsAwsjson11_deserializeOpPutJobFailureResult struct { 2993} 2994 2995func (*awsAwsjson11_deserializeOpPutJobFailureResult) ID() string { 2996 return "OperationDeserializer" 2997} 2998 2999func (m *awsAwsjson11_deserializeOpPutJobFailureResult) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3000 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3001) { 3002 out, metadata, err = next.HandleDeserialize(ctx, in) 3003 if err != nil { 3004 return out, metadata, err 3005 } 3006 3007 response, ok := out.RawResponse.(*smithyhttp.Response) 3008 if !ok { 3009 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3010 } 3011 3012 if response.StatusCode < 200 || response.StatusCode >= 300 { 3013 return out, metadata, awsAwsjson11_deserializeOpErrorPutJobFailureResult(response, &metadata) 3014 } 3015 output := &PutJobFailureResultOutput{} 3016 out.Result = output 3017 3018 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3019 return out, metadata, &smithy.DeserializationError{ 3020 Err: fmt.Errorf("failed to discard response body, %w", err), 3021 } 3022 } 3023 3024 return out, metadata, err 3025} 3026 3027func awsAwsjson11_deserializeOpErrorPutJobFailureResult(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3028 var errorBuffer bytes.Buffer 3029 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3030 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3031 } 3032 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3033 3034 errorCode := "UnknownError" 3035 errorMessage := errorCode 3036 3037 code := response.Header.Get("X-Amzn-ErrorType") 3038 if len(code) != 0 { 3039 errorCode = restjson.SanitizeErrorCode(code) 3040 } 3041 3042 var buff [1024]byte 3043 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3044 3045 body := io.TeeReader(errorBody, ringBuffer) 3046 decoder := json.NewDecoder(body) 3047 decoder.UseNumber() 3048 code, message, err := restjson.GetErrorInfo(decoder) 3049 if err != nil { 3050 var snapshot bytes.Buffer 3051 io.Copy(&snapshot, ringBuffer) 3052 err = &smithy.DeserializationError{ 3053 Err: fmt.Errorf("failed to decode response body, %w", err), 3054 Snapshot: snapshot.Bytes(), 3055 } 3056 return err 3057 } 3058 3059 errorBody.Seek(0, io.SeekStart) 3060 if len(code) != 0 { 3061 errorCode = restjson.SanitizeErrorCode(code) 3062 } 3063 if len(message) != 0 { 3064 errorMessage = message 3065 } 3066 3067 switch { 3068 case strings.EqualFold("InvalidJobStateException", errorCode): 3069 return awsAwsjson11_deserializeErrorInvalidJobStateException(response, errorBody) 3070 3071 case strings.EqualFold("JobNotFoundException", errorCode): 3072 return awsAwsjson11_deserializeErrorJobNotFoundException(response, errorBody) 3073 3074 case strings.EqualFold("ValidationException", errorCode): 3075 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3076 3077 default: 3078 genericError := &smithy.GenericAPIError{ 3079 Code: errorCode, 3080 Message: errorMessage, 3081 } 3082 return genericError 3083 3084 } 3085} 3086 3087type awsAwsjson11_deserializeOpPutJobSuccessResult struct { 3088} 3089 3090func (*awsAwsjson11_deserializeOpPutJobSuccessResult) ID() string { 3091 return "OperationDeserializer" 3092} 3093 3094func (m *awsAwsjson11_deserializeOpPutJobSuccessResult) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3095 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3096) { 3097 out, metadata, err = next.HandleDeserialize(ctx, in) 3098 if err != nil { 3099 return out, metadata, err 3100 } 3101 3102 response, ok := out.RawResponse.(*smithyhttp.Response) 3103 if !ok { 3104 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3105 } 3106 3107 if response.StatusCode < 200 || response.StatusCode >= 300 { 3108 return out, metadata, awsAwsjson11_deserializeOpErrorPutJobSuccessResult(response, &metadata) 3109 } 3110 output := &PutJobSuccessResultOutput{} 3111 out.Result = output 3112 3113 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3114 return out, metadata, &smithy.DeserializationError{ 3115 Err: fmt.Errorf("failed to discard response body, %w", err), 3116 } 3117 } 3118 3119 return out, metadata, err 3120} 3121 3122func awsAwsjson11_deserializeOpErrorPutJobSuccessResult(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3123 var errorBuffer bytes.Buffer 3124 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3125 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3126 } 3127 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3128 3129 errorCode := "UnknownError" 3130 errorMessage := errorCode 3131 3132 code := response.Header.Get("X-Amzn-ErrorType") 3133 if len(code) != 0 { 3134 errorCode = restjson.SanitizeErrorCode(code) 3135 } 3136 3137 var buff [1024]byte 3138 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3139 3140 body := io.TeeReader(errorBody, ringBuffer) 3141 decoder := json.NewDecoder(body) 3142 decoder.UseNumber() 3143 code, message, err := restjson.GetErrorInfo(decoder) 3144 if err != nil { 3145 var snapshot bytes.Buffer 3146 io.Copy(&snapshot, ringBuffer) 3147 err = &smithy.DeserializationError{ 3148 Err: fmt.Errorf("failed to decode response body, %w", err), 3149 Snapshot: snapshot.Bytes(), 3150 } 3151 return err 3152 } 3153 3154 errorBody.Seek(0, io.SeekStart) 3155 if len(code) != 0 { 3156 errorCode = restjson.SanitizeErrorCode(code) 3157 } 3158 if len(message) != 0 { 3159 errorMessage = message 3160 } 3161 3162 switch { 3163 case strings.EqualFold("InvalidJobStateException", errorCode): 3164 return awsAwsjson11_deserializeErrorInvalidJobStateException(response, errorBody) 3165 3166 case strings.EqualFold("JobNotFoundException", errorCode): 3167 return awsAwsjson11_deserializeErrorJobNotFoundException(response, errorBody) 3168 3169 case strings.EqualFold("OutputVariablesSizeExceededException", errorCode): 3170 return awsAwsjson11_deserializeErrorOutputVariablesSizeExceededException(response, errorBody) 3171 3172 case strings.EqualFold("ValidationException", errorCode): 3173 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3174 3175 default: 3176 genericError := &smithy.GenericAPIError{ 3177 Code: errorCode, 3178 Message: errorMessage, 3179 } 3180 return genericError 3181 3182 } 3183} 3184 3185type awsAwsjson11_deserializeOpPutThirdPartyJobFailureResult struct { 3186} 3187 3188func (*awsAwsjson11_deserializeOpPutThirdPartyJobFailureResult) ID() string { 3189 return "OperationDeserializer" 3190} 3191 3192func (m *awsAwsjson11_deserializeOpPutThirdPartyJobFailureResult) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3193 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3194) { 3195 out, metadata, err = next.HandleDeserialize(ctx, in) 3196 if err != nil { 3197 return out, metadata, err 3198 } 3199 3200 response, ok := out.RawResponse.(*smithyhttp.Response) 3201 if !ok { 3202 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3203 } 3204 3205 if response.StatusCode < 200 || response.StatusCode >= 300 { 3206 return out, metadata, awsAwsjson11_deserializeOpErrorPutThirdPartyJobFailureResult(response, &metadata) 3207 } 3208 output := &PutThirdPartyJobFailureResultOutput{} 3209 out.Result = output 3210 3211 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3212 return out, metadata, &smithy.DeserializationError{ 3213 Err: fmt.Errorf("failed to discard response body, %w", err), 3214 } 3215 } 3216 3217 return out, metadata, err 3218} 3219 3220func awsAwsjson11_deserializeOpErrorPutThirdPartyJobFailureResult(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3221 var errorBuffer bytes.Buffer 3222 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3223 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3224 } 3225 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3226 3227 errorCode := "UnknownError" 3228 errorMessage := errorCode 3229 3230 code := response.Header.Get("X-Amzn-ErrorType") 3231 if len(code) != 0 { 3232 errorCode = restjson.SanitizeErrorCode(code) 3233 } 3234 3235 var buff [1024]byte 3236 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3237 3238 body := io.TeeReader(errorBody, ringBuffer) 3239 decoder := json.NewDecoder(body) 3240 decoder.UseNumber() 3241 code, message, err := restjson.GetErrorInfo(decoder) 3242 if err != nil { 3243 var snapshot bytes.Buffer 3244 io.Copy(&snapshot, ringBuffer) 3245 err = &smithy.DeserializationError{ 3246 Err: fmt.Errorf("failed to decode response body, %w", err), 3247 Snapshot: snapshot.Bytes(), 3248 } 3249 return err 3250 } 3251 3252 errorBody.Seek(0, io.SeekStart) 3253 if len(code) != 0 { 3254 errorCode = restjson.SanitizeErrorCode(code) 3255 } 3256 if len(message) != 0 { 3257 errorMessage = message 3258 } 3259 3260 switch { 3261 case strings.EqualFold("InvalidClientTokenException", errorCode): 3262 return awsAwsjson11_deserializeErrorInvalidClientTokenException(response, errorBody) 3263 3264 case strings.EqualFold("InvalidJobStateException", errorCode): 3265 return awsAwsjson11_deserializeErrorInvalidJobStateException(response, errorBody) 3266 3267 case strings.EqualFold("JobNotFoundException", errorCode): 3268 return awsAwsjson11_deserializeErrorJobNotFoundException(response, errorBody) 3269 3270 case strings.EqualFold("ValidationException", errorCode): 3271 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3272 3273 default: 3274 genericError := &smithy.GenericAPIError{ 3275 Code: errorCode, 3276 Message: errorMessage, 3277 } 3278 return genericError 3279 3280 } 3281} 3282 3283type awsAwsjson11_deserializeOpPutThirdPartyJobSuccessResult struct { 3284} 3285 3286func (*awsAwsjson11_deserializeOpPutThirdPartyJobSuccessResult) ID() string { 3287 return "OperationDeserializer" 3288} 3289 3290func (m *awsAwsjson11_deserializeOpPutThirdPartyJobSuccessResult) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3291 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3292) { 3293 out, metadata, err = next.HandleDeserialize(ctx, in) 3294 if err != nil { 3295 return out, metadata, err 3296 } 3297 3298 response, ok := out.RawResponse.(*smithyhttp.Response) 3299 if !ok { 3300 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3301 } 3302 3303 if response.StatusCode < 200 || response.StatusCode >= 300 { 3304 return out, metadata, awsAwsjson11_deserializeOpErrorPutThirdPartyJobSuccessResult(response, &metadata) 3305 } 3306 output := &PutThirdPartyJobSuccessResultOutput{} 3307 out.Result = output 3308 3309 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3310 return out, metadata, &smithy.DeserializationError{ 3311 Err: fmt.Errorf("failed to discard response body, %w", err), 3312 } 3313 } 3314 3315 return out, metadata, err 3316} 3317 3318func awsAwsjson11_deserializeOpErrorPutThirdPartyJobSuccessResult(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3319 var errorBuffer bytes.Buffer 3320 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3321 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3322 } 3323 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3324 3325 errorCode := "UnknownError" 3326 errorMessage := errorCode 3327 3328 code := response.Header.Get("X-Amzn-ErrorType") 3329 if len(code) != 0 { 3330 errorCode = restjson.SanitizeErrorCode(code) 3331 } 3332 3333 var buff [1024]byte 3334 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3335 3336 body := io.TeeReader(errorBody, ringBuffer) 3337 decoder := json.NewDecoder(body) 3338 decoder.UseNumber() 3339 code, message, err := restjson.GetErrorInfo(decoder) 3340 if err != nil { 3341 var snapshot bytes.Buffer 3342 io.Copy(&snapshot, ringBuffer) 3343 err = &smithy.DeserializationError{ 3344 Err: fmt.Errorf("failed to decode response body, %w", err), 3345 Snapshot: snapshot.Bytes(), 3346 } 3347 return err 3348 } 3349 3350 errorBody.Seek(0, io.SeekStart) 3351 if len(code) != 0 { 3352 errorCode = restjson.SanitizeErrorCode(code) 3353 } 3354 if len(message) != 0 { 3355 errorMessage = message 3356 } 3357 3358 switch { 3359 case strings.EqualFold("InvalidClientTokenException", errorCode): 3360 return awsAwsjson11_deserializeErrorInvalidClientTokenException(response, errorBody) 3361 3362 case strings.EqualFold("InvalidJobStateException", errorCode): 3363 return awsAwsjson11_deserializeErrorInvalidJobStateException(response, errorBody) 3364 3365 case strings.EqualFold("JobNotFoundException", errorCode): 3366 return awsAwsjson11_deserializeErrorJobNotFoundException(response, errorBody) 3367 3368 case strings.EqualFold("ValidationException", errorCode): 3369 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3370 3371 default: 3372 genericError := &smithy.GenericAPIError{ 3373 Code: errorCode, 3374 Message: errorMessage, 3375 } 3376 return genericError 3377 3378 } 3379} 3380 3381type awsAwsjson11_deserializeOpPutWebhook struct { 3382} 3383 3384func (*awsAwsjson11_deserializeOpPutWebhook) ID() string { 3385 return "OperationDeserializer" 3386} 3387 3388func (m *awsAwsjson11_deserializeOpPutWebhook) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3389 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3390) { 3391 out, metadata, err = next.HandleDeserialize(ctx, in) 3392 if err != nil { 3393 return out, metadata, err 3394 } 3395 3396 response, ok := out.RawResponse.(*smithyhttp.Response) 3397 if !ok { 3398 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3399 } 3400 3401 if response.StatusCode < 200 || response.StatusCode >= 300 { 3402 return out, metadata, awsAwsjson11_deserializeOpErrorPutWebhook(response, &metadata) 3403 } 3404 output := &PutWebhookOutput{} 3405 out.Result = output 3406 3407 var buff [1024]byte 3408 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3409 3410 body := io.TeeReader(response.Body, ringBuffer) 3411 decoder := json.NewDecoder(body) 3412 decoder.UseNumber() 3413 var shape interface{} 3414 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3415 var snapshot bytes.Buffer 3416 io.Copy(&snapshot, ringBuffer) 3417 err = &smithy.DeserializationError{ 3418 Err: fmt.Errorf("failed to decode response body, %w", err), 3419 Snapshot: snapshot.Bytes(), 3420 } 3421 return out, metadata, err 3422 } 3423 3424 err = awsAwsjson11_deserializeOpDocumentPutWebhookOutput(&output, shape) 3425 if err != nil { 3426 var snapshot bytes.Buffer 3427 io.Copy(&snapshot, ringBuffer) 3428 err = &smithy.DeserializationError{ 3429 Err: fmt.Errorf("failed to decode response body, %w", err), 3430 Snapshot: snapshot.Bytes(), 3431 } 3432 return out, metadata, err 3433 } 3434 3435 return out, metadata, err 3436} 3437 3438func awsAwsjson11_deserializeOpErrorPutWebhook(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3439 var errorBuffer bytes.Buffer 3440 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3441 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3442 } 3443 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3444 3445 errorCode := "UnknownError" 3446 errorMessage := errorCode 3447 3448 code := response.Header.Get("X-Amzn-ErrorType") 3449 if len(code) != 0 { 3450 errorCode = restjson.SanitizeErrorCode(code) 3451 } 3452 3453 var buff [1024]byte 3454 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3455 3456 body := io.TeeReader(errorBody, ringBuffer) 3457 decoder := json.NewDecoder(body) 3458 decoder.UseNumber() 3459 code, message, err := restjson.GetErrorInfo(decoder) 3460 if err != nil { 3461 var snapshot bytes.Buffer 3462 io.Copy(&snapshot, ringBuffer) 3463 err = &smithy.DeserializationError{ 3464 Err: fmt.Errorf("failed to decode response body, %w", err), 3465 Snapshot: snapshot.Bytes(), 3466 } 3467 return err 3468 } 3469 3470 errorBody.Seek(0, io.SeekStart) 3471 if len(code) != 0 { 3472 errorCode = restjson.SanitizeErrorCode(code) 3473 } 3474 if len(message) != 0 { 3475 errorMessage = message 3476 } 3477 3478 switch { 3479 case strings.EqualFold("ConcurrentModificationException", errorCode): 3480 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 3481 3482 case strings.EqualFold("InvalidTagsException", errorCode): 3483 return awsAwsjson11_deserializeErrorInvalidTagsException(response, errorBody) 3484 3485 case strings.EqualFold("InvalidWebhookAuthenticationParametersException", errorCode): 3486 return awsAwsjson11_deserializeErrorInvalidWebhookAuthenticationParametersException(response, errorBody) 3487 3488 case strings.EqualFold("InvalidWebhookFilterPatternException", errorCode): 3489 return awsAwsjson11_deserializeErrorInvalidWebhookFilterPatternException(response, errorBody) 3490 3491 case strings.EqualFold("LimitExceededException", errorCode): 3492 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 3493 3494 case strings.EqualFold("PipelineNotFoundException", errorCode): 3495 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 3496 3497 case strings.EqualFold("TooManyTagsException", errorCode): 3498 return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody) 3499 3500 case strings.EqualFold("ValidationException", errorCode): 3501 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3502 3503 default: 3504 genericError := &smithy.GenericAPIError{ 3505 Code: errorCode, 3506 Message: errorMessage, 3507 } 3508 return genericError 3509 3510 } 3511} 3512 3513type awsAwsjson11_deserializeOpRegisterWebhookWithThirdParty struct { 3514} 3515 3516func (*awsAwsjson11_deserializeOpRegisterWebhookWithThirdParty) ID() string { 3517 return "OperationDeserializer" 3518} 3519 3520func (m *awsAwsjson11_deserializeOpRegisterWebhookWithThirdParty) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3521 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3522) { 3523 out, metadata, err = next.HandleDeserialize(ctx, in) 3524 if err != nil { 3525 return out, metadata, err 3526 } 3527 3528 response, ok := out.RawResponse.(*smithyhttp.Response) 3529 if !ok { 3530 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3531 } 3532 3533 if response.StatusCode < 200 || response.StatusCode >= 300 { 3534 return out, metadata, awsAwsjson11_deserializeOpErrorRegisterWebhookWithThirdParty(response, &metadata) 3535 } 3536 output := &RegisterWebhookWithThirdPartyOutput{} 3537 out.Result = output 3538 3539 var buff [1024]byte 3540 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3541 3542 body := io.TeeReader(response.Body, ringBuffer) 3543 decoder := json.NewDecoder(body) 3544 decoder.UseNumber() 3545 var shape interface{} 3546 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3547 var snapshot bytes.Buffer 3548 io.Copy(&snapshot, ringBuffer) 3549 err = &smithy.DeserializationError{ 3550 Err: fmt.Errorf("failed to decode response body, %w", err), 3551 Snapshot: snapshot.Bytes(), 3552 } 3553 return out, metadata, err 3554 } 3555 3556 err = awsAwsjson11_deserializeOpDocumentRegisterWebhookWithThirdPartyOutput(&output, shape) 3557 if err != nil { 3558 var snapshot bytes.Buffer 3559 io.Copy(&snapshot, ringBuffer) 3560 err = &smithy.DeserializationError{ 3561 Err: fmt.Errorf("failed to decode response body, %w", err), 3562 Snapshot: snapshot.Bytes(), 3563 } 3564 return out, metadata, err 3565 } 3566 3567 return out, metadata, err 3568} 3569 3570func awsAwsjson11_deserializeOpErrorRegisterWebhookWithThirdParty(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3571 var errorBuffer bytes.Buffer 3572 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3573 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3574 } 3575 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3576 3577 errorCode := "UnknownError" 3578 errorMessage := errorCode 3579 3580 code := response.Header.Get("X-Amzn-ErrorType") 3581 if len(code) != 0 { 3582 errorCode = restjson.SanitizeErrorCode(code) 3583 } 3584 3585 var buff [1024]byte 3586 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3587 3588 body := io.TeeReader(errorBody, ringBuffer) 3589 decoder := json.NewDecoder(body) 3590 decoder.UseNumber() 3591 code, message, err := restjson.GetErrorInfo(decoder) 3592 if err != nil { 3593 var snapshot bytes.Buffer 3594 io.Copy(&snapshot, ringBuffer) 3595 err = &smithy.DeserializationError{ 3596 Err: fmt.Errorf("failed to decode response body, %w", err), 3597 Snapshot: snapshot.Bytes(), 3598 } 3599 return err 3600 } 3601 3602 errorBody.Seek(0, io.SeekStart) 3603 if len(code) != 0 { 3604 errorCode = restjson.SanitizeErrorCode(code) 3605 } 3606 if len(message) != 0 { 3607 errorMessage = message 3608 } 3609 3610 switch { 3611 case strings.EqualFold("ValidationException", errorCode): 3612 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3613 3614 case strings.EqualFold("WebhookNotFoundException", errorCode): 3615 return awsAwsjson11_deserializeErrorWebhookNotFoundException(response, errorBody) 3616 3617 default: 3618 genericError := &smithy.GenericAPIError{ 3619 Code: errorCode, 3620 Message: errorMessage, 3621 } 3622 return genericError 3623 3624 } 3625} 3626 3627type awsAwsjson11_deserializeOpRetryStageExecution struct { 3628} 3629 3630func (*awsAwsjson11_deserializeOpRetryStageExecution) ID() string { 3631 return "OperationDeserializer" 3632} 3633 3634func (m *awsAwsjson11_deserializeOpRetryStageExecution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3635 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3636) { 3637 out, metadata, err = next.HandleDeserialize(ctx, in) 3638 if err != nil { 3639 return out, metadata, err 3640 } 3641 3642 response, ok := out.RawResponse.(*smithyhttp.Response) 3643 if !ok { 3644 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3645 } 3646 3647 if response.StatusCode < 200 || response.StatusCode >= 300 { 3648 return out, metadata, awsAwsjson11_deserializeOpErrorRetryStageExecution(response, &metadata) 3649 } 3650 output := &RetryStageExecutionOutput{} 3651 out.Result = output 3652 3653 var buff [1024]byte 3654 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3655 3656 body := io.TeeReader(response.Body, ringBuffer) 3657 decoder := json.NewDecoder(body) 3658 decoder.UseNumber() 3659 var shape interface{} 3660 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3661 var snapshot bytes.Buffer 3662 io.Copy(&snapshot, ringBuffer) 3663 err = &smithy.DeserializationError{ 3664 Err: fmt.Errorf("failed to decode response body, %w", err), 3665 Snapshot: snapshot.Bytes(), 3666 } 3667 return out, metadata, err 3668 } 3669 3670 err = awsAwsjson11_deserializeOpDocumentRetryStageExecutionOutput(&output, shape) 3671 if err != nil { 3672 var snapshot bytes.Buffer 3673 io.Copy(&snapshot, ringBuffer) 3674 err = &smithy.DeserializationError{ 3675 Err: fmt.Errorf("failed to decode response body, %w", err), 3676 Snapshot: snapshot.Bytes(), 3677 } 3678 return out, metadata, err 3679 } 3680 3681 return out, metadata, err 3682} 3683 3684func awsAwsjson11_deserializeOpErrorRetryStageExecution(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3685 var errorBuffer bytes.Buffer 3686 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3687 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3688 } 3689 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3690 3691 errorCode := "UnknownError" 3692 errorMessage := errorCode 3693 3694 code := response.Header.Get("X-Amzn-ErrorType") 3695 if len(code) != 0 { 3696 errorCode = restjson.SanitizeErrorCode(code) 3697 } 3698 3699 var buff [1024]byte 3700 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3701 3702 body := io.TeeReader(errorBody, ringBuffer) 3703 decoder := json.NewDecoder(body) 3704 decoder.UseNumber() 3705 code, message, err := restjson.GetErrorInfo(decoder) 3706 if err != nil { 3707 var snapshot bytes.Buffer 3708 io.Copy(&snapshot, ringBuffer) 3709 err = &smithy.DeserializationError{ 3710 Err: fmt.Errorf("failed to decode response body, %w", err), 3711 Snapshot: snapshot.Bytes(), 3712 } 3713 return err 3714 } 3715 3716 errorBody.Seek(0, io.SeekStart) 3717 if len(code) != 0 { 3718 errorCode = restjson.SanitizeErrorCode(code) 3719 } 3720 if len(message) != 0 { 3721 errorMessage = message 3722 } 3723 3724 switch { 3725 case strings.EqualFold("ConflictException", errorCode): 3726 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 3727 3728 case strings.EqualFold("NotLatestPipelineExecutionException", errorCode): 3729 return awsAwsjson11_deserializeErrorNotLatestPipelineExecutionException(response, errorBody) 3730 3731 case strings.EqualFold("PipelineNotFoundException", errorCode): 3732 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 3733 3734 case strings.EqualFold("StageNotFoundException", errorCode): 3735 return awsAwsjson11_deserializeErrorStageNotFoundException(response, errorBody) 3736 3737 case strings.EqualFold("StageNotRetryableException", errorCode): 3738 return awsAwsjson11_deserializeErrorStageNotRetryableException(response, errorBody) 3739 3740 case strings.EqualFold("ValidationException", errorCode): 3741 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3742 3743 default: 3744 genericError := &smithy.GenericAPIError{ 3745 Code: errorCode, 3746 Message: errorMessage, 3747 } 3748 return genericError 3749 3750 } 3751} 3752 3753type awsAwsjson11_deserializeOpStartPipelineExecution struct { 3754} 3755 3756func (*awsAwsjson11_deserializeOpStartPipelineExecution) ID() string { 3757 return "OperationDeserializer" 3758} 3759 3760func (m *awsAwsjson11_deserializeOpStartPipelineExecution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3761 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3762) { 3763 out, metadata, err = next.HandleDeserialize(ctx, in) 3764 if err != nil { 3765 return out, metadata, err 3766 } 3767 3768 response, ok := out.RawResponse.(*smithyhttp.Response) 3769 if !ok { 3770 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3771 } 3772 3773 if response.StatusCode < 200 || response.StatusCode >= 300 { 3774 return out, metadata, awsAwsjson11_deserializeOpErrorStartPipelineExecution(response, &metadata) 3775 } 3776 output := &StartPipelineExecutionOutput{} 3777 out.Result = output 3778 3779 var buff [1024]byte 3780 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3781 3782 body := io.TeeReader(response.Body, ringBuffer) 3783 decoder := json.NewDecoder(body) 3784 decoder.UseNumber() 3785 var shape interface{} 3786 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3787 var snapshot bytes.Buffer 3788 io.Copy(&snapshot, ringBuffer) 3789 err = &smithy.DeserializationError{ 3790 Err: fmt.Errorf("failed to decode response body, %w", err), 3791 Snapshot: snapshot.Bytes(), 3792 } 3793 return out, metadata, err 3794 } 3795 3796 err = awsAwsjson11_deserializeOpDocumentStartPipelineExecutionOutput(&output, shape) 3797 if err != nil { 3798 var snapshot bytes.Buffer 3799 io.Copy(&snapshot, ringBuffer) 3800 err = &smithy.DeserializationError{ 3801 Err: fmt.Errorf("failed to decode response body, %w", err), 3802 Snapshot: snapshot.Bytes(), 3803 } 3804 return out, metadata, err 3805 } 3806 3807 return out, metadata, err 3808} 3809 3810func awsAwsjson11_deserializeOpErrorStartPipelineExecution(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3811 var errorBuffer bytes.Buffer 3812 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3813 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3814 } 3815 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3816 3817 errorCode := "UnknownError" 3818 errorMessage := errorCode 3819 3820 code := response.Header.Get("X-Amzn-ErrorType") 3821 if len(code) != 0 { 3822 errorCode = restjson.SanitizeErrorCode(code) 3823 } 3824 3825 var buff [1024]byte 3826 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3827 3828 body := io.TeeReader(errorBody, ringBuffer) 3829 decoder := json.NewDecoder(body) 3830 decoder.UseNumber() 3831 code, message, err := restjson.GetErrorInfo(decoder) 3832 if err != nil { 3833 var snapshot bytes.Buffer 3834 io.Copy(&snapshot, ringBuffer) 3835 err = &smithy.DeserializationError{ 3836 Err: fmt.Errorf("failed to decode response body, %w", err), 3837 Snapshot: snapshot.Bytes(), 3838 } 3839 return err 3840 } 3841 3842 errorBody.Seek(0, io.SeekStart) 3843 if len(code) != 0 { 3844 errorCode = restjson.SanitizeErrorCode(code) 3845 } 3846 if len(message) != 0 { 3847 errorMessage = message 3848 } 3849 3850 switch { 3851 case strings.EqualFold("ConflictException", errorCode): 3852 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 3853 3854 case strings.EqualFold("PipelineNotFoundException", errorCode): 3855 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 3856 3857 case strings.EqualFold("ValidationException", errorCode): 3858 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3859 3860 default: 3861 genericError := &smithy.GenericAPIError{ 3862 Code: errorCode, 3863 Message: errorMessage, 3864 } 3865 return genericError 3866 3867 } 3868} 3869 3870type awsAwsjson11_deserializeOpStopPipelineExecution struct { 3871} 3872 3873func (*awsAwsjson11_deserializeOpStopPipelineExecution) ID() string { 3874 return "OperationDeserializer" 3875} 3876 3877func (m *awsAwsjson11_deserializeOpStopPipelineExecution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3878 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3879) { 3880 out, metadata, err = next.HandleDeserialize(ctx, in) 3881 if err != nil { 3882 return out, metadata, err 3883 } 3884 3885 response, ok := out.RawResponse.(*smithyhttp.Response) 3886 if !ok { 3887 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3888 } 3889 3890 if response.StatusCode < 200 || response.StatusCode >= 300 { 3891 return out, metadata, awsAwsjson11_deserializeOpErrorStopPipelineExecution(response, &metadata) 3892 } 3893 output := &StopPipelineExecutionOutput{} 3894 out.Result = output 3895 3896 var buff [1024]byte 3897 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3898 3899 body := io.TeeReader(response.Body, ringBuffer) 3900 decoder := json.NewDecoder(body) 3901 decoder.UseNumber() 3902 var shape interface{} 3903 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3904 var snapshot bytes.Buffer 3905 io.Copy(&snapshot, ringBuffer) 3906 err = &smithy.DeserializationError{ 3907 Err: fmt.Errorf("failed to decode response body, %w", err), 3908 Snapshot: snapshot.Bytes(), 3909 } 3910 return out, metadata, err 3911 } 3912 3913 err = awsAwsjson11_deserializeOpDocumentStopPipelineExecutionOutput(&output, shape) 3914 if err != nil { 3915 var snapshot bytes.Buffer 3916 io.Copy(&snapshot, ringBuffer) 3917 err = &smithy.DeserializationError{ 3918 Err: fmt.Errorf("failed to decode response body, %w", err), 3919 Snapshot: snapshot.Bytes(), 3920 } 3921 return out, metadata, err 3922 } 3923 3924 return out, metadata, err 3925} 3926 3927func awsAwsjson11_deserializeOpErrorStopPipelineExecution(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3928 var errorBuffer bytes.Buffer 3929 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3930 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3931 } 3932 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3933 3934 errorCode := "UnknownError" 3935 errorMessage := errorCode 3936 3937 code := response.Header.Get("X-Amzn-ErrorType") 3938 if len(code) != 0 { 3939 errorCode = restjson.SanitizeErrorCode(code) 3940 } 3941 3942 var buff [1024]byte 3943 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3944 3945 body := io.TeeReader(errorBody, ringBuffer) 3946 decoder := json.NewDecoder(body) 3947 decoder.UseNumber() 3948 code, message, err := restjson.GetErrorInfo(decoder) 3949 if err != nil { 3950 var snapshot bytes.Buffer 3951 io.Copy(&snapshot, ringBuffer) 3952 err = &smithy.DeserializationError{ 3953 Err: fmt.Errorf("failed to decode response body, %w", err), 3954 Snapshot: snapshot.Bytes(), 3955 } 3956 return err 3957 } 3958 3959 errorBody.Seek(0, io.SeekStart) 3960 if len(code) != 0 { 3961 errorCode = restjson.SanitizeErrorCode(code) 3962 } 3963 if len(message) != 0 { 3964 errorMessage = message 3965 } 3966 3967 switch { 3968 case strings.EqualFold("ConflictException", errorCode): 3969 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 3970 3971 case strings.EqualFold("DuplicatedStopRequestException", errorCode): 3972 return awsAwsjson11_deserializeErrorDuplicatedStopRequestException(response, errorBody) 3973 3974 case strings.EqualFold("PipelineExecutionNotStoppableException", errorCode): 3975 return awsAwsjson11_deserializeErrorPipelineExecutionNotStoppableException(response, errorBody) 3976 3977 case strings.EqualFold("PipelineNotFoundException", errorCode): 3978 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 3979 3980 case strings.EqualFold("ValidationException", errorCode): 3981 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3982 3983 default: 3984 genericError := &smithy.GenericAPIError{ 3985 Code: errorCode, 3986 Message: errorMessage, 3987 } 3988 return genericError 3989 3990 } 3991} 3992 3993type awsAwsjson11_deserializeOpTagResource struct { 3994} 3995 3996func (*awsAwsjson11_deserializeOpTagResource) ID() string { 3997 return "OperationDeserializer" 3998} 3999 4000func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4001 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4002) { 4003 out, metadata, err = next.HandleDeserialize(ctx, in) 4004 if err != nil { 4005 return out, metadata, err 4006 } 4007 4008 response, ok := out.RawResponse.(*smithyhttp.Response) 4009 if !ok { 4010 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4011 } 4012 4013 if response.StatusCode < 200 || response.StatusCode >= 300 { 4014 return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata) 4015 } 4016 output := &TagResourceOutput{} 4017 out.Result = output 4018 4019 var buff [1024]byte 4020 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4021 4022 body := io.TeeReader(response.Body, ringBuffer) 4023 decoder := json.NewDecoder(body) 4024 decoder.UseNumber() 4025 var shape interface{} 4026 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4027 var snapshot bytes.Buffer 4028 io.Copy(&snapshot, ringBuffer) 4029 err = &smithy.DeserializationError{ 4030 Err: fmt.Errorf("failed to decode response body, %w", err), 4031 Snapshot: snapshot.Bytes(), 4032 } 4033 return out, metadata, err 4034 } 4035 4036 err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape) 4037 if err != nil { 4038 var snapshot bytes.Buffer 4039 io.Copy(&snapshot, ringBuffer) 4040 err = &smithy.DeserializationError{ 4041 Err: fmt.Errorf("failed to decode response body, %w", err), 4042 Snapshot: snapshot.Bytes(), 4043 } 4044 return out, metadata, err 4045 } 4046 4047 return out, metadata, err 4048} 4049 4050func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4051 var errorBuffer bytes.Buffer 4052 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4053 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4054 } 4055 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4056 4057 errorCode := "UnknownError" 4058 errorMessage := errorCode 4059 4060 code := response.Header.Get("X-Amzn-ErrorType") 4061 if len(code) != 0 { 4062 errorCode = restjson.SanitizeErrorCode(code) 4063 } 4064 4065 var buff [1024]byte 4066 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4067 4068 body := io.TeeReader(errorBody, ringBuffer) 4069 decoder := json.NewDecoder(body) 4070 decoder.UseNumber() 4071 code, message, err := restjson.GetErrorInfo(decoder) 4072 if err != nil { 4073 var snapshot bytes.Buffer 4074 io.Copy(&snapshot, ringBuffer) 4075 err = &smithy.DeserializationError{ 4076 Err: fmt.Errorf("failed to decode response body, %w", err), 4077 Snapshot: snapshot.Bytes(), 4078 } 4079 return err 4080 } 4081 4082 errorBody.Seek(0, io.SeekStart) 4083 if len(code) != 0 { 4084 errorCode = restjson.SanitizeErrorCode(code) 4085 } 4086 if len(message) != 0 { 4087 errorMessage = message 4088 } 4089 4090 switch { 4091 case strings.EqualFold("ConcurrentModificationException", errorCode): 4092 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 4093 4094 case strings.EqualFold("InvalidArnException", errorCode): 4095 return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) 4096 4097 case strings.EqualFold("InvalidTagsException", errorCode): 4098 return awsAwsjson11_deserializeErrorInvalidTagsException(response, errorBody) 4099 4100 case strings.EqualFold("ResourceNotFoundException", errorCode): 4101 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4102 4103 case strings.EqualFold("TooManyTagsException", errorCode): 4104 return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody) 4105 4106 case strings.EqualFold("ValidationException", errorCode): 4107 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 4108 4109 default: 4110 genericError := &smithy.GenericAPIError{ 4111 Code: errorCode, 4112 Message: errorMessage, 4113 } 4114 return genericError 4115 4116 } 4117} 4118 4119type awsAwsjson11_deserializeOpUntagResource struct { 4120} 4121 4122func (*awsAwsjson11_deserializeOpUntagResource) ID() string { 4123 return "OperationDeserializer" 4124} 4125 4126func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4127 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4128) { 4129 out, metadata, err = next.HandleDeserialize(ctx, in) 4130 if err != nil { 4131 return out, metadata, err 4132 } 4133 4134 response, ok := out.RawResponse.(*smithyhttp.Response) 4135 if !ok { 4136 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4137 } 4138 4139 if response.StatusCode < 200 || response.StatusCode >= 300 { 4140 return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata) 4141 } 4142 output := &UntagResourceOutput{} 4143 out.Result = output 4144 4145 var buff [1024]byte 4146 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4147 4148 body := io.TeeReader(response.Body, ringBuffer) 4149 decoder := json.NewDecoder(body) 4150 decoder.UseNumber() 4151 var shape interface{} 4152 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4153 var snapshot bytes.Buffer 4154 io.Copy(&snapshot, ringBuffer) 4155 err = &smithy.DeserializationError{ 4156 Err: fmt.Errorf("failed to decode response body, %w", err), 4157 Snapshot: snapshot.Bytes(), 4158 } 4159 return out, metadata, err 4160 } 4161 4162 err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape) 4163 if err != nil { 4164 var snapshot bytes.Buffer 4165 io.Copy(&snapshot, ringBuffer) 4166 err = &smithy.DeserializationError{ 4167 Err: fmt.Errorf("failed to decode response body, %w", err), 4168 Snapshot: snapshot.Bytes(), 4169 } 4170 return out, metadata, err 4171 } 4172 4173 return out, metadata, err 4174} 4175 4176func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4177 var errorBuffer bytes.Buffer 4178 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4179 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4180 } 4181 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4182 4183 errorCode := "UnknownError" 4184 errorMessage := errorCode 4185 4186 code := response.Header.Get("X-Amzn-ErrorType") 4187 if len(code) != 0 { 4188 errorCode = restjson.SanitizeErrorCode(code) 4189 } 4190 4191 var buff [1024]byte 4192 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4193 4194 body := io.TeeReader(errorBody, ringBuffer) 4195 decoder := json.NewDecoder(body) 4196 decoder.UseNumber() 4197 code, message, err := restjson.GetErrorInfo(decoder) 4198 if err != nil { 4199 var snapshot bytes.Buffer 4200 io.Copy(&snapshot, ringBuffer) 4201 err = &smithy.DeserializationError{ 4202 Err: fmt.Errorf("failed to decode response body, %w", err), 4203 Snapshot: snapshot.Bytes(), 4204 } 4205 return err 4206 } 4207 4208 errorBody.Seek(0, io.SeekStart) 4209 if len(code) != 0 { 4210 errorCode = restjson.SanitizeErrorCode(code) 4211 } 4212 if len(message) != 0 { 4213 errorMessage = message 4214 } 4215 4216 switch { 4217 case strings.EqualFold("ConcurrentModificationException", errorCode): 4218 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 4219 4220 case strings.EqualFold("InvalidArnException", errorCode): 4221 return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) 4222 4223 case strings.EqualFold("InvalidTagsException", errorCode): 4224 return awsAwsjson11_deserializeErrorInvalidTagsException(response, errorBody) 4225 4226 case strings.EqualFold("ResourceNotFoundException", errorCode): 4227 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4228 4229 case strings.EqualFold("ValidationException", errorCode): 4230 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 4231 4232 default: 4233 genericError := &smithy.GenericAPIError{ 4234 Code: errorCode, 4235 Message: errorMessage, 4236 } 4237 return genericError 4238 4239 } 4240} 4241 4242type awsAwsjson11_deserializeOpUpdateActionType struct { 4243} 4244 4245func (*awsAwsjson11_deserializeOpUpdateActionType) ID() string { 4246 return "OperationDeserializer" 4247} 4248 4249func (m *awsAwsjson11_deserializeOpUpdateActionType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4250 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4251) { 4252 out, metadata, err = next.HandleDeserialize(ctx, in) 4253 if err != nil { 4254 return out, metadata, err 4255 } 4256 4257 response, ok := out.RawResponse.(*smithyhttp.Response) 4258 if !ok { 4259 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4260 } 4261 4262 if response.StatusCode < 200 || response.StatusCode >= 300 { 4263 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateActionType(response, &metadata) 4264 } 4265 output := &UpdateActionTypeOutput{} 4266 out.Result = output 4267 4268 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 4269 return out, metadata, &smithy.DeserializationError{ 4270 Err: fmt.Errorf("failed to discard response body, %w", err), 4271 } 4272 } 4273 4274 return out, metadata, err 4275} 4276 4277func awsAwsjson11_deserializeOpErrorUpdateActionType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4278 var errorBuffer bytes.Buffer 4279 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4280 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4281 } 4282 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4283 4284 errorCode := "UnknownError" 4285 errorMessage := errorCode 4286 4287 code := response.Header.Get("X-Amzn-ErrorType") 4288 if len(code) != 0 { 4289 errorCode = restjson.SanitizeErrorCode(code) 4290 } 4291 4292 var buff [1024]byte 4293 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4294 4295 body := io.TeeReader(errorBody, ringBuffer) 4296 decoder := json.NewDecoder(body) 4297 decoder.UseNumber() 4298 code, message, err := restjson.GetErrorInfo(decoder) 4299 if err != nil { 4300 var snapshot bytes.Buffer 4301 io.Copy(&snapshot, ringBuffer) 4302 err = &smithy.DeserializationError{ 4303 Err: fmt.Errorf("failed to decode response body, %w", err), 4304 Snapshot: snapshot.Bytes(), 4305 } 4306 return err 4307 } 4308 4309 errorBody.Seek(0, io.SeekStart) 4310 if len(code) != 0 { 4311 errorCode = restjson.SanitizeErrorCode(code) 4312 } 4313 if len(message) != 0 { 4314 errorMessage = message 4315 } 4316 4317 switch { 4318 case strings.EqualFold("ActionTypeNotFoundException", errorCode): 4319 return awsAwsjson11_deserializeErrorActionTypeNotFoundException(response, errorBody) 4320 4321 case strings.EqualFold("RequestFailedException", errorCode): 4322 return awsAwsjson11_deserializeErrorRequestFailedException(response, errorBody) 4323 4324 case strings.EqualFold("ValidationException", errorCode): 4325 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 4326 4327 default: 4328 genericError := &smithy.GenericAPIError{ 4329 Code: errorCode, 4330 Message: errorMessage, 4331 } 4332 return genericError 4333 4334 } 4335} 4336 4337type awsAwsjson11_deserializeOpUpdatePipeline struct { 4338} 4339 4340func (*awsAwsjson11_deserializeOpUpdatePipeline) ID() string { 4341 return "OperationDeserializer" 4342} 4343 4344func (m *awsAwsjson11_deserializeOpUpdatePipeline) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4345 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4346) { 4347 out, metadata, err = next.HandleDeserialize(ctx, in) 4348 if err != nil { 4349 return out, metadata, err 4350 } 4351 4352 response, ok := out.RawResponse.(*smithyhttp.Response) 4353 if !ok { 4354 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4355 } 4356 4357 if response.StatusCode < 200 || response.StatusCode >= 300 { 4358 return out, metadata, awsAwsjson11_deserializeOpErrorUpdatePipeline(response, &metadata) 4359 } 4360 output := &UpdatePipelineOutput{} 4361 out.Result = output 4362 4363 var buff [1024]byte 4364 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4365 4366 body := io.TeeReader(response.Body, ringBuffer) 4367 decoder := json.NewDecoder(body) 4368 decoder.UseNumber() 4369 var shape interface{} 4370 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4371 var snapshot bytes.Buffer 4372 io.Copy(&snapshot, ringBuffer) 4373 err = &smithy.DeserializationError{ 4374 Err: fmt.Errorf("failed to decode response body, %w", err), 4375 Snapshot: snapshot.Bytes(), 4376 } 4377 return out, metadata, err 4378 } 4379 4380 err = awsAwsjson11_deserializeOpDocumentUpdatePipelineOutput(&output, shape) 4381 if err != nil { 4382 var snapshot bytes.Buffer 4383 io.Copy(&snapshot, ringBuffer) 4384 err = &smithy.DeserializationError{ 4385 Err: fmt.Errorf("failed to decode response body, %w", err), 4386 Snapshot: snapshot.Bytes(), 4387 } 4388 return out, metadata, err 4389 } 4390 4391 return out, metadata, err 4392} 4393 4394func awsAwsjson11_deserializeOpErrorUpdatePipeline(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4395 var errorBuffer bytes.Buffer 4396 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4397 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4398 } 4399 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4400 4401 errorCode := "UnknownError" 4402 errorMessage := errorCode 4403 4404 code := response.Header.Get("X-Amzn-ErrorType") 4405 if len(code) != 0 { 4406 errorCode = restjson.SanitizeErrorCode(code) 4407 } 4408 4409 var buff [1024]byte 4410 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4411 4412 body := io.TeeReader(errorBody, ringBuffer) 4413 decoder := json.NewDecoder(body) 4414 decoder.UseNumber() 4415 code, message, err := restjson.GetErrorInfo(decoder) 4416 if err != nil { 4417 var snapshot bytes.Buffer 4418 io.Copy(&snapshot, ringBuffer) 4419 err = &smithy.DeserializationError{ 4420 Err: fmt.Errorf("failed to decode response body, %w", err), 4421 Snapshot: snapshot.Bytes(), 4422 } 4423 return err 4424 } 4425 4426 errorBody.Seek(0, io.SeekStart) 4427 if len(code) != 0 { 4428 errorCode = restjson.SanitizeErrorCode(code) 4429 } 4430 if len(message) != 0 { 4431 errorMessage = message 4432 } 4433 4434 switch { 4435 case strings.EqualFold("InvalidActionDeclarationException", errorCode): 4436 return awsAwsjson11_deserializeErrorInvalidActionDeclarationException(response, errorBody) 4437 4438 case strings.EqualFold("InvalidBlockerDeclarationException", errorCode): 4439 return awsAwsjson11_deserializeErrorInvalidBlockerDeclarationException(response, errorBody) 4440 4441 case strings.EqualFold("InvalidStageDeclarationException", errorCode): 4442 return awsAwsjson11_deserializeErrorInvalidStageDeclarationException(response, errorBody) 4443 4444 case strings.EqualFold("InvalidStructureException", errorCode): 4445 return awsAwsjson11_deserializeErrorInvalidStructureException(response, errorBody) 4446 4447 case strings.EqualFold("LimitExceededException", errorCode): 4448 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 4449 4450 case strings.EqualFold("ValidationException", errorCode): 4451 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 4452 4453 default: 4454 genericError := &smithy.GenericAPIError{ 4455 Code: errorCode, 4456 Message: errorMessage, 4457 } 4458 return genericError 4459 4460 } 4461} 4462 4463func awsAwsjson11_deserializeErrorActionNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4464 var buff [1024]byte 4465 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4466 4467 body := io.TeeReader(errorBody, ringBuffer) 4468 decoder := json.NewDecoder(body) 4469 decoder.UseNumber() 4470 var shape interface{} 4471 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4472 var snapshot bytes.Buffer 4473 io.Copy(&snapshot, ringBuffer) 4474 err = &smithy.DeserializationError{ 4475 Err: fmt.Errorf("failed to decode response body, %w", err), 4476 Snapshot: snapshot.Bytes(), 4477 } 4478 return err 4479 } 4480 4481 output := &types.ActionNotFoundException{} 4482 err := awsAwsjson11_deserializeDocumentActionNotFoundException(&output, shape) 4483 4484 if err != nil { 4485 var snapshot bytes.Buffer 4486 io.Copy(&snapshot, ringBuffer) 4487 err = &smithy.DeserializationError{ 4488 Err: fmt.Errorf("failed to decode response body, %w", err), 4489 Snapshot: snapshot.Bytes(), 4490 } 4491 return err 4492 } 4493 4494 errorBody.Seek(0, io.SeekStart) 4495 return output 4496} 4497 4498func awsAwsjson11_deserializeErrorActionTypeNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4499 var buff [1024]byte 4500 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4501 4502 body := io.TeeReader(errorBody, ringBuffer) 4503 decoder := json.NewDecoder(body) 4504 decoder.UseNumber() 4505 var shape interface{} 4506 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4507 var snapshot bytes.Buffer 4508 io.Copy(&snapshot, ringBuffer) 4509 err = &smithy.DeserializationError{ 4510 Err: fmt.Errorf("failed to decode response body, %w", err), 4511 Snapshot: snapshot.Bytes(), 4512 } 4513 return err 4514 } 4515 4516 output := &types.ActionTypeNotFoundException{} 4517 err := awsAwsjson11_deserializeDocumentActionTypeNotFoundException(&output, shape) 4518 4519 if err != nil { 4520 var snapshot bytes.Buffer 4521 io.Copy(&snapshot, ringBuffer) 4522 err = &smithy.DeserializationError{ 4523 Err: fmt.Errorf("failed to decode response body, %w", err), 4524 Snapshot: snapshot.Bytes(), 4525 } 4526 return err 4527 } 4528 4529 errorBody.Seek(0, io.SeekStart) 4530 return output 4531} 4532 4533func awsAwsjson11_deserializeErrorApprovalAlreadyCompletedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4534 var buff [1024]byte 4535 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4536 4537 body := io.TeeReader(errorBody, ringBuffer) 4538 decoder := json.NewDecoder(body) 4539 decoder.UseNumber() 4540 var shape interface{} 4541 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4542 var snapshot bytes.Buffer 4543 io.Copy(&snapshot, ringBuffer) 4544 err = &smithy.DeserializationError{ 4545 Err: fmt.Errorf("failed to decode response body, %w", err), 4546 Snapshot: snapshot.Bytes(), 4547 } 4548 return err 4549 } 4550 4551 output := &types.ApprovalAlreadyCompletedException{} 4552 err := awsAwsjson11_deserializeDocumentApprovalAlreadyCompletedException(&output, shape) 4553 4554 if err != nil { 4555 var snapshot bytes.Buffer 4556 io.Copy(&snapshot, ringBuffer) 4557 err = &smithy.DeserializationError{ 4558 Err: fmt.Errorf("failed to decode response body, %w", err), 4559 Snapshot: snapshot.Bytes(), 4560 } 4561 return err 4562 } 4563 4564 errorBody.Seek(0, io.SeekStart) 4565 return output 4566} 4567 4568func awsAwsjson11_deserializeErrorConcurrentModificationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4569 var buff [1024]byte 4570 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4571 4572 body := io.TeeReader(errorBody, ringBuffer) 4573 decoder := json.NewDecoder(body) 4574 decoder.UseNumber() 4575 var shape interface{} 4576 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4577 var snapshot bytes.Buffer 4578 io.Copy(&snapshot, ringBuffer) 4579 err = &smithy.DeserializationError{ 4580 Err: fmt.Errorf("failed to decode response body, %w", err), 4581 Snapshot: snapshot.Bytes(), 4582 } 4583 return err 4584 } 4585 4586 output := &types.ConcurrentModificationException{} 4587 err := awsAwsjson11_deserializeDocumentConcurrentModificationException(&output, shape) 4588 4589 if err != nil { 4590 var snapshot bytes.Buffer 4591 io.Copy(&snapshot, ringBuffer) 4592 err = &smithy.DeserializationError{ 4593 Err: fmt.Errorf("failed to decode response body, %w", err), 4594 Snapshot: snapshot.Bytes(), 4595 } 4596 return err 4597 } 4598 4599 errorBody.Seek(0, io.SeekStart) 4600 return output 4601} 4602 4603func awsAwsjson11_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4604 var buff [1024]byte 4605 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4606 4607 body := io.TeeReader(errorBody, ringBuffer) 4608 decoder := json.NewDecoder(body) 4609 decoder.UseNumber() 4610 var shape interface{} 4611 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4612 var snapshot bytes.Buffer 4613 io.Copy(&snapshot, ringBuffer) 4614 err = &smithy.DeserializationError{ 4615 Err: fmt.Errorf("failed to decode response body, %w", err), 4616 Snapshot: snapshot.Bytes(), 4617 } 4618 return err 4619 } 4620 4621 output := &types.ConflictException{} 4622 err := awsAwsjson11_deserializeDocumentConflictException(&output, shape) 4623 4624 if err != nil { 4625 var snapshot bytes.Buffer 4626 io.Copy(&snapshot, ringBuffer) 4627 err = &smithy.DeserializationError{ 4628 Err: fmt.Errorf("failed to decode response body, %w", err), 4629 Snapshot: snapshot.Bytes(), 4630 } 4631 return err 4632 } 4633 4634 errorBody.Seek(0, io.SeekStart) 4635 return output 4636} 4637 4638func awsAwsjson11_deserializeErrorDuplicatedStopRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4639 var buff [1024]byte 4640 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4641 4642 body := io.TeeReader(errorBody, ringBuffer) 4643 decoder := json.NewDecoder(body) 4644 decoder.UseNumber() 4645 var shape interface{} 4646 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4647 var snapshot bytes.Buffer 4648 io.Copy(&snapshot, ringBuffer) 4649 err = &smithy.DeserializationError{ 4650 Err: fmt.Errorf("failed to decode response body, %w", err), 4651 Snapshot: snapshot.Bytes(), 4652 } 4653 return err 4654 } 4655 4656 output := &types.DuplicatedStopRequestException{} 4657 err := awsAwsjson11_deserializeDocumentDuplicatedStopRequestException(&output, shape) 4658 4659 if err != nil { 4660 var snapshot bytes.Buffer 4661 io.Copy(&snapshot, ringBuffer) 4662 err = &smithy.DeserializationError{ 4663 Err: fmt.Errorf("failed to decode response body, %w", err), 4664 Snapshot: snapshot.Bytes(), 4665 } 4666 return err 4667 } 4668 4669 errorBody.Seek(0, io.SeekStart) 4670 return output 4671} 4672 4673func awsAwsjson11_deserializeErrorInvalidActionDeclarationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4674 var buff [1024]byte 4675 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4676 4677 body := io.TeeReader(errorBody, ringBuffer) 4678 decoder := json.NewDecoder(body) 4679 decoder.UseNumber() 4680 var shape interface{} 4681 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4682 var snapshot bytes.Buffer 4683 io.Copy(&snapshot, ringBuffer) 4684 err = &smithy.DeserializationError{ 4685 Err: fmt.Errorf("failed to decode response body, %w", err), 4686 Snapshot: snapshot.Bytes(), 4687 } 4688 return err 4689 } 4690 4691 output := &types.InvalidActionDeclarationException{} 4692 err := awsAwsjson11_deserializeDocumentInvalidActionDeclarationException(&output, shape) 4693 4694 if err != nil { 4695 var snapshot bytes.Buffer 4696 io.Copy(&snapshot, ringBuffer) 4697 err = &smithy.DeserializationError{ 4698 Err: fmt.Errorf("failed to decode response body, %w", err), 4699 Snapshot: snapshot.Bytes(), 4700 } 4701 return err 4702 } 4703 4704 errorBody.Seek(0, io.SeekStart) 4705 return output 4706} 4707 4708func awsAwsjson11_deserializeErrorInvalidApprovalTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4709 var buff [1024]byte 4710 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4711 4712 body := io.TeeReader(errorBody, ringBuffer) 4713 decoder := json.NewDecoder(body) 4714 decoder.UseNumber() 4715 var shape interface{} 4716 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4717 var snapshot bytes.Buffer 4718 io.Copy(&snapshot, ringBuffer) 4719 err = &smithy.DeserializationError{ 4720 Err: fmt.Errorf("failed to decode response body, %w", err), 4721 Snapshot: snapshot.Bytes(), 4722 } 4723 return err 4724 } 4725 4726 output := &types.InvalidApprovalTokenException{} 4727 err := awsAwsjson11_deserializeDocumentInvalidApprovalTokenException(&output, shape) 4728 4729 if err != nil { 4730 var snapshot bytes.Buffer 4731 io.Copy(&snapshot, ringBuffer) 4732 err = &smithy.DeserializationError{ 4733 Err: fmt.Errorf("failed to decode response body, %w", err), 4734 Snapshot: snapshot.Bytes(), 4735 } 4736 return err 4737 } 4738 4739 errorBody.Seek(0, io.SeekStart) 4740 return output 4741} 4742 4743func awsAwsjson11_deserializeErrorInvalidArnException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4744 var buff [1024]byte 4745 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4746 4747 body := io.TeeReader(errorBody, ringBuffer) 4748 decoder := json.NewDecoder(body) 4749 decoder.UseNumber() 4750 var shape interface{} 4751 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4752 var snapshot bytes.Buffer 4753 io.Copy(&snapshot, ringBuffer) 4754 err = &smithy.DeserializationError{ 4755 Err: fmt.Errorf("failed to decode response body, %w", err), 4756 Snapshot: snapshot.Bytes(), 4757 } 4758 return err 4759 } 4760 4761 output := &types.InvalidArnException{} 4762 err := awsAwsjson11_deserializeDocumentInvalidArnException(&output, shape) 4763 4764 if err != nil { 4765 var snapshot bytes.Buffer 4766 io.Copy(&snapshot, ringBuffer) 4767 err = &smithy.DeserializationError{ 4768 Err: fmt.Errorf("failed to decode response body, %w", err), 4769 Snapshot: snapshot.Bytes(), 4770 } 4771 return err 4772 } 4773 4774 errorBody.Seek(0, io.SeekStart) 4775 return output 4776} 4777 4778func awsAwsjson11_deserializeErrorInvalidBlockerDeclarationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4779 var buff [1024]byte 4780 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4781 4782 body := io.TeeReader(errorBody, ringBuffer) 4783 decoder := json.NewDecoder(body) 4784 decoder.UseNumber() 4785 var shape interface{} 4786 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4787 var snapshot bytes.Buffer 4788 io.Copy(&snapshot, ringBuffer) 4789 err = &smithy.DeserializationError{ 4790 Err: fmt.Errorf("failed to decode response body, %w", err), 4791 Snapshot: snapshot.Bytes(), 4792 } 4793 return err 4794 } 4795 4796 output := &types.InvalidBlockerDeclarationException{} 4797 err := awsAwsjson11_deserializeDocumentInvalidBlockerDeclarationException(&output, shape) 4798 4799 if err != nil { 4800 var snapshot bytes.Buffer 4801 io.Copy(&snapshot, ringBuffer) 4802 err = &smithy.DeserializationError{ 4803 Err: fmt.Errorf("failed to decode response body, %w", err), 4804 Snapshot: snapshot.Bytes(), 4805 } 4806 return err 4807 } 4808 4809 errorBody.Seek(0, io.SeekStart) 4810 return output 4811} 4812 4813func awsAwsjson11_deserializeErrorInvalidClientTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4814 var buff [1024]byte 4815 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4816 4817 body := io.TeeReader(errorBody, ringBuffer) 4818 decoder := json.NewDecoder(body) 4819 decoder.UseNumber() 4820 var shape interface{} 4821 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4822 var snapshot bytes.Buffer 4823 io.Copy(&snapshot, ringBuffer) 4824 err = &smithy.DeserializationError{ 4825 Err: fmt.Errorf("failed to decode response body, %w", err), 4826 Snapshot: snapshot.Bytes(), 4827 } 4828 return err 4829 } 4830 4831 output := &types.InvalidClientTokenException{} 4832 err := awsAwsjson11_deserializeDocumentInvalidClientTokenException(&output, shape) 4833 4834 if err != nil { 4835 var snapshot bytes.Buffer 4836 io.Copy(&snapshot, ringBuffer) 4837 err = &smithy.DeserializationError{ 4838 Err: fmt.Errorf("failed to decode response body, %w", err), 4839 Snapshot: snapshot.Bytes(), 4840 } 4841 return err 4842 } 4843 4844 errorBody.Seek(0, io.SeekStart) 4845 return output 4846} 4847 4848func awsAwsjson11_deserializeErrorInvalidJobException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4849 var buff [1024]byte 4850 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4851 4852 body := io.TeeReader(errorBody, ringBuffer) 4853 decoder := json.NewDecoder(body) 4854 decoder.UseNumber() 4855 var shape interface{} 4856 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4857 var snapshot bytes.Buffer 4858 io.Copy(&snapshot, ringBuffer) 4859 err = &smithy.DeserializationError{ 4860 Err: fmt.Errorf("failed to decode response body, %w", err), 4861 Snapshot: snapshot.Bytes(), 4862 } 4863 return err 4864 } 4865 4866 output := &types.InvalidJobException{} 4867 err := awsAwsjson11_deserializeDocumentInvalidJobException(&output, shape) 4868 4869 if err != nil { 4870 var snapshot bytes.Buffer 4871 io.Copy(&snapshot, ringBuffer) 4872 err = &smithy.DeserializationError{ 4873 Err: fmt.Errorf("failed to decode response body, %w", err), 4874 Snapshot: snapshot.Bytes(), 4875 } 4876 return err 4877 } 4878 4879 errorBody.Seek(0, io.SeekStart) 4880 return output 4881} 4882 4883func awsAwsjson11_deserializeErrorInvalidJobStateException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4884 var buff [1024]byte 4885 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4886 4887 body := io.TeeReader(errorBody, ringBuffer) 4888 decoder := json.NewDecoder(body) 4889 decoder.UseNumber() 4890 var shape interface{} 4891 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4892 var snapshot bytes.Buffer 4893 io.Copy(&snapshot, ringBuffer) 4894 err = &smithy.DeserializationError{ 4895 Err: fmt.Errorf("failed to decode response body, %w", err), 4896 Snapshot: snapshot.Bytes(), 4897 } 4898 return err 4899 } 4900 4901 output := &types.InvalidJobStateException{} 4902 err := awsAwsjson11_deserializeDocumentInvalidJobStateException(&output, shape) 4903 4904 if err != nil { 4905 var snapshot bytes.Buffer 4906 io.Copy(&snapshot, ringBuffer) 4907 err = &smithy.DeserializationError{ 4908 Err: fmt.Errorf("failed to decode response body, %w", err), 4909 Snapshot: snapshot.Bytes(), 4910 } 4911 return err 4912 } 4913 4914 errorBody.Seek(0, io.SeekStart) 4915 return output 4916} 4917 4918func awsAwsjson11_deserializeErrorInvalidNextTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4919 var buff [1024]byte 4920 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4921 4922 body := io.TeeReader(errorBody, ringBuffer) 4923 decoder := json.NewDecoder(body) 4924 decoder.UseNumber() 4925 var shape interface{} 4926 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4927 var snapshot bytes.Buffer 4928 io.Copy(&snapshot, ringBuffer) 4929 err = &smithy.DeserializationError{ 4930 Err: fmt.Errorf("failed to decode response body, %w", err), 4931 Snapshot: snapshot.Bytes(), 4932 } 4933 return err 4934 } 4935 4936 output := &types.InvalidNextTokenException{} 4937 err := awsAwsjson11_deserializeDocumentInvalidNextTokenException(&output, shape) 4938 4939 if err != nil { 4940 var snapshot bytes.Buffer 4941 io.Copy(&snapshot, ringBuffer) 4942 err = &smithy.DeserializationError{ 4943 Err: fmt.Errorf("failed to decode response body, %w", err), 4944 Snapshot: snapshot.Bytes(), 4945 } 4946 return err 4947 } 4948 4949 errorBody.Seek(0, io.SeekStart) 4950 return output 4951} 4952 4953func awsAwsjson11_deserializeErrorInvalidNonceException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4954 var buff [1024]byte 4955 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4956 4957 body := io.TeeReader(errorBody, ringBuffer) 4958 decoder := json.NewDecoder(body) 4959 decoder.UseNumber() 4960 var shape interface{} 4961 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4962 var snapshot bytes.Buffer 4963 io.Copy(&snapshot, ringBuffer) 4964 err = &smithy.DeserializationError{ 4965 Err: fmt.Errorf("failed to decode response body, %w", err), 4966 Snapshot: snapshot.Bytes(), 4967 } 4968 return err 4969 } 4970 4971 output := &types.InvalidNonceException{} 4972 err := awsAwsjson11_deserializeDocumentInvalidNonceException(&output, shape) 4973 4974 if err != nil { 4975 var snapshot bytes.Buffer 4976 io.Copy(&snapshot, ringBuffer) 4977 err = &smithy.DeserializationError{ 4978 Err: fmt.Errorf("failed to decode response body, %w", err), 4979 Snapshot: snapshot.Bytes(), 4980 } 4981 return err 4982 } 4983 4984 errorBody.Seek(0, io.SeekStart) 4985 return output 4986} 4987 4988func awsAwsjson11_deserializeErrorInvalidStageDeclarationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4989 var buff [1024]byte 4990 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4991 4992 body := io.TeeReader(errorBody, ringBuffer) 4993 decoder := json.NewDecoder(body) 4994 decoder.UseNumber() 4995 var shape interface{} 4996 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4997 var snapshot bytes.Buffer 4998 io.Copy(&snapshot, ringBuffer) 4999 err = &smithy.DeserializationError{ 5000 Err: fmt.Errorf("failed to decode response body, %w", err), 5001 Snapshot: snapshot.Bytes(), 5002 } 5003 return err 5004 } 5005 5006 output := &types.InvalidStageDeclarationException{} 5007 err := awsAwsjson11_deserializeDocumentInvalidStageDeclarationException(&output, shape) 5008 5009 if err != nil { 5010 var snapshot bytes.Buffer 5011 io.Copy(&snapshot, ringBuffer) 5012 err = &smithy.DeserializationError{ 5013 Err: fmt.Errorf("failed to decode response body, %w", err), 5014 Snapshot: snapshot.Bytes(), 5015 } 5016 return err 5017 } 5018 5019 errorBody.Seek(0, io.SeekStart) 5020 return output 5021} 5022 5023func awsAwsjson11_deserializeErrorInvalidStructureException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5024 var buff [1024]byte 5025 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5026 5027 body := io.TeeReader(errorBody, ringBuffer) 5028 decoder := json.NewDecoder(body) 5029 decoder.UseNumber() 5030 var shape interface{} 5031 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5032 var snapshot bytes.Buffer 5033 io.Copy(&snapshot, ringBuffer) 5034 err = &smithy.DeserializationError{ 5035 Err: fmt.Errorf("failed to decode response body, %w", err), 5036 Snapshot: snapshot.Bytes(), 5037 } 5038 return err 5039 } 5040 5041 output := &types.InvalidStructureException{} 5042 err := awsAwsjson11_deserializeDocumentInvalidStructureException(&output, shape) 5043 5044 if err != nil { 5045 var snapshot bytes.Buffer 5046 io.Copy(&snapshot, ringBuffer) 5047 err = &smithy.DeserializationError{ 5048 Err: fmt.Errorf("failed to decode response body, %w", err), 5049 Snapshot: snapshot.Bytes(), 5050 } 5051 return err 5052 } 5053 5054 errorBody.Seek(0, io.SeekStart) 5055 return output 5056} 5057 5058func awsAwsjson11_deserializeErrorInvalidTagsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5059 var buff [1024]byte 5060 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5061 5062 body := io.TeeReader(errorBody, ringBuffer) 5063 decoder := json.NewDecoder(body) 5064 decoder.UseNumber() 5065 var shape interface{} 5066 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5067 var snapshot bytes.Buffer 5068 io.Copy(&snapshot, ringBuffer) 5069 err = &smithy.DeserializationError{ 5070 Err: fmt.Errorf("failed to decode response body, %w", err), 5071 Snapshot: snapshot.Bytes(), 5072 } 5073 return err 5074 } 5075 5076 output := &types.InvalidTagsException{} 5077 err := awsAwsjson11_deserializeDocumentInvalidTagsException(&output, shape) 5078 5079 if err != nil { 5080 var snapshot bytes.Buffer 5081 io.Copy(&snapshot, ringBuffer) 5082 err = &smithy.DeserializationError{ 5083 Err: fmt.Errorf("failed to decode response body, %w", err), 5084 Snapshot: snapshot.Bytes(), 5085 } 5086 return err 5087 } 5088 5089 errorBody.Seek(0, io.SeekStart) 5090 return output 5091} 5092 5093func awsAwsjson11_deserializeErrorInvalidWebhookAuthenticationParametersException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5094 var buff [1024]byte 5095 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5096 5097 body := io.TeeReader(errorBody, ringBuffer) 5098 decoder := json.NewDecoder(body) 5099 decoder.UseNumber() 5100 var shape interface{} 5101 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5102 var snapshot bytes.Buffer 5103 io.Copy(&snapshot, ringBuffer) 5104 err = &smithy.DeserializationError{ 5105 Err: fmt.Errorf("failed to decode response body, %w", err), 5106 Snapshot: snapshot.Bytes(), 5107 } 5108 return err 5109 } 5110 5111 output := &types.InvalidWebhookAuthenticationParametersException{} 5112 err := awsAwsjson11_deserializeDocumentInvalidWebhookAuthenticationParametersException(&output, shape) 5113 5114 if err != nil { 5115 var snapshot bytes.Buffer 5116 io.Copy(&snapshot, ringBuffer) 5117 err = &smithy.DeserializationError{ 5118 Err: fmt.Errorf("failed to decode response body, %w", err), 5119 Snapshot: snapshot.Bytes(), 5120 } 5121 return err 5122 } 5123 5124 errorBody.Seek(0, io.SeekStart) 5125 return output 5126} 5127 5128func awsAwsjson11_deserializeErrorInvalidWebhookFilterPatternException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5129 var buff [1024]byte 5130 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5131 5132 body := io.TeeReader(errorBody, ringBuffer) 5133 decoder := json.NewDecoder(body) 5134 decoder.UseNumber() 5135 var shape interface{} 5136 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5137 var snapshot bytes.Buffer 5138 io.Copy(&snapshot, ringBuffer) 5139 err = &smithy.DeserializationError{ 5140 Err: fmt.Errorf("failed to decode response body, %w", err), 5141 Snapshot: snapshot.Bytes(), 5142 } 5143 return err 5144 } 5145 5146 output := &types.InvalidWebhookFilterPatternException{} 5147 err := awsAwsjson11_deserializeDocumentInvalidWebhookFilterPatternException(&output, shape) 5148 5149 if err != nil { 5150 var snapshot bytes.Buffer 5151 io.Copy(&snapshot, ringBuffer) 5152 err = &smithy.DeserializationError{ 5153 Err: fmt.Errorf("failed to decode response body, %w", err), 5154 Snapshot: snapshot.Bytes(), 5155 } 5156 return err 5157 } 5158 5159 errorBody.Seek(0, io.SeekStart) 5160 return output 5161} 5162 5163func awsAwsjson11_deserializeErrorJobNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5164 var buff [1024]byte 5165 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5166 5167 body := io.TeeReader(errorBody, ringBuffer) 5168 decoder := json.NewDecoder(body) 5169 decoder.UseNumber() 5170 var shape interface{} 5171 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5172 var snapshot bytes.Buffer 5173 io.Copy(&snapshot, ringBuffer) 5174 err = &smithy.DeserializationError{ 5175 Err: fmt.Errorf("failed to decode response body, %w", err), 5176 Snapshot: snapshot.Bytes(), 5177 } 5178 return err 5179 } 5180 5181 output := &types.JobNotFoundException{} 5182 err := awsAwsjson11_deserializeDocumentJobNotFoundException(&output, shape) 5183 5184 if err != nil { 5185 var snapshot bytes.Buffer 5186 io.Copy(&snapshot, ringBuffer) 5187 err = &smithy.DeserializationError{ 5188 Err: fmt.Errorf("failed to decode response body, %w", err), 5189 Snapshot: snapshot.Bytes(), 5190 } 5191 return err 5192 } 5193 5194 errorBody.Seek(0, io.SeekStart) 5195 return output 5196} 5197 5198func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5199 var buff [1024]byte 5200 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5201 5202 body := io.TeeReader(errorBody, ringBuffer) 5203 decoder := json.NewDecoder(body) 5204 decoder.UseNumber() 5205 var shape interface{} 5206 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5207 var snapshot bytes.Buffer 5208 io.Copy(&snapshot, ringBuffer) 5209 err = &smithy.DeserializationError{ 5210 Err: fmt.Errorf("failed to decode response body, %w", err), 5211 Snapshot: snapshot.Bytes(), 5212 } 5213 return err 5214 } 5215 5216 output := &types.LimitExceededException{} 5217 err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape) 5218 5219 if err != nil { 5220 var snapshot bytes.Buffer 5221 io.Copy(&snapshot, ringBuffer) 5222 err = &smithy.DeserializationError{ 5223 Err: fmt.Errorf("failed to decode response body, %w", err), 5224 Snapshot: snapshot.Bytes(), 5225 } 5226 return err 5227 } 5228 5229 errorBody.Seek(0, io.SeekStart) 5230 return output 5231} 5232 5233func awsAwsjson11_deserializeErrorNotLatestPipelineExecutionException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5234 var buff [1024]byte 5235 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5236 5237 body := io.TeeReader(errorBody, ringBuffer) 5238 decoder := json.NewDecoder(body) 5239 decoder.UseNumber() 5240 var shape interface{} 5241 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5242 var snapshot bytes.Buffer 5243 io.Copy(&snapshot, ringBuffer) 5244 err = &smithy.DeserializationError{ 5245 Err: fmt.Errorf("failed to decode response body, %w", err), 5246 Snapshot: snapshot.Bytes(), 5247 } 5248 return err 5249 } 5250 5251 output := &types.NotLatestPipelineExecutionException{} 5252 err := awsAwsjson11_deserializeDocumentNotLatestPipelineExecutionException(&output, shape) 5253 5254 if err != nil { 5255 var snapshot bytes.Buffer 5256 io.Copy(&snapshot, ringBuffer) 5257 err = &smithy.DeserializationError{ 5258 Err: fmt.Errorf("failed to decode response body, %w", err), 5259 Snapshot: snapshot.Bytes(), 5260 } 5261 return err 5262 } 5263 5264 errorBody.Seek(0, io.SeekStart) 5265 return output 5266} 5267 5268func awsAwsjson11_deserializeErrorOutputVariablesSizeExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5269 var buff [1024]byte 5270 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5271 5272 body := io.TeeReader(errorBody, ringBuffer) 5273 decoder := json.NewDecoder(body) 5274 decoder.UseNumber() 5275 var shape interface{} 5276 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5277 var snapshot bytes.Buffer 5278 io.Copy(&snapshot, ringBuffer) 5279 err = &smithy.DeserializationError{ 5280 Err: fmt.Errorf("failed to decode response body, %w", err), 5281 Snapshot: snapshot.Bytes(), 5282 } 5283 return err 5284 } 5285 5286 output := &types.OutputVariablesSizeExceededException{} 5287 err := awsAwsjson11_deserializeDocumentOutputVariablesSizeExceededException(&output, shape) 5288 5289 if err != nil { 5290 var snapshot bytes.Buffer 5291 io.Copy(&snapshot, ringBuffer) 5292 err = &smithy.DeserializationError{ 5293 Err: fmt.Errorf("failed to decode response body, %w", err), 5294 Snapshot: snapshot.Bytes(), 5295 } 5296 return err 5297 } 5298 5299 errorBody.Seek(0, io.SeekStart) 5300 return output 5301} 5302 5303func awsAwsjson11_deserializeErrorPipelineExecutionNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5304 var buff [1024]byte 5305 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5306 5307 body := io.TeeReader(errorBody, ringBuffer) 5308 decoder := json.NewDecoder(body) 5309 decoder.UseNumber() 5310 var shape interface{} 5311 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5312 var snapshot bytes.Buffer 5313 io.Copy(&snapshot, ringBuffer) 5314 err = &smithy.DeserializationError{ 5315 Err: fmt.Errorf("failed to decode response body, %w", err), 5316 Snapshot: snapshot.Bytes(), 5317 } 5318 return err 5319 } 5320 5321 output := &types.PipelineExecutionNotFoundException{} 5322 err := awsAwsjson11_deserializeDocumentPipelineExecutionNotFoundException(&output, shape) 5323 5324 if err != nil { 5325 var snapshot bytes.Buffer 5326 io.Copy(&snapshot, ringBuffer) 5327 err = &smithy.DeserializationError{ 5328 Err: fmt.Errorf("failed to decode response body, %w", err), 5329 Snapshot: snapshot.Bytes(), 5330 } 5331 return err 5332 } 5333 5334 errorBody.Seek(0, io.SeekStart) 5335 return output 5336} 5337 5338func awsAwsjson11_deserializeErrorPipelineExecutionNotStoppableException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5339 var buff [1024]byte 5340 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5341 5342 body := io.TeeReader(errorBody, ringBuffer) 5343 decoder := json.NewDecoder(body) 5344 decoder.UseNumber() 5345 var shape interface{} 5346 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5347 var snapshot bytes.Buffer 5348 io.Copy(&snapshot, ringBuffer) 5349 err = &smithy.DeserializationError{ 5350 Err: fmt.Errorf("failed to decode response body, %w", err), 5351 Snapshot: snapshot.Bytes(), 5352 } 5353 return err 5354 } 5355 5356 output := &types.PipelineExecutionNotStoppableException{} 5357 err := awsAwsjson11_deserializeDocumentPipelineExecutionNotStoppableException(&output, shape) 5358 5359 if err != nil { 5360 var snapshot bytes.Buffer 5361 io.Copy(&snapshot, ringBuffer) 5362 err = &smithy.DeserializationError{ 5363 Err: fmt.Errorf("failed to decode response body, %w", err), 5364 Snapshot: snapshot.Bytes(), 5365 } 5366 return err 5367 } 5368 5369 errorBody.Seek(0, io.SeekStart) 5370 return output 5371} 5372 5373func awsAwsjson11_deserializeErrorPipelineNameInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5374 var buff [1024]byte 5375 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5376 5377 body := io.TeeReader(errorBody, ringBuffer) 5378 decoder := json.NewDecoder(body) 5379 decoder.UseNumber() 5380 var shape interface{} 5381 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5382 var snapshot bytes.Buffer 5383 io.Copy(&snapshot, ringBuffer) 5384 err = &smithy.DeserializationError{ 5385 Err: fmt.Errorf("failed to decode response body, %w", err), 5386 Snapshot: snapshot.Bytes(), 5387 } 5388 return err 5389 } 5390 5391 output := &types.PipelineNameInUseException{} 5392 err := awsAwsjson11_deserializeDocumentPipelineNameInUseException(&output, shape) 5393 5394 if err != nil { 5395 var snapshot bytes.Buffer 5396 io.Copy(&snapshot, ringBuffer) 5397 err = &smithy.DeserializationError{ 5398 Err: fmt.Errorf("failed to decode response body, %w", err), 5399 Snapshot: snapshot.Bytes(), 5400 } 5401 return err 5402 } 5403 5404 errorBody.Seek(0, io.SeekStart) 5405 return output 5406} 5407 5408func awsAwsjson11_deserializeErrorPipelineNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5409 var buff [1024]byte 5410 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5411 5412 body := io.TeeReader(errorBody, ringBuffer) 5413 decoder := json.NewDecoder(body) 5414 decoder.UseNumber() 5415 var shape interface{} 5416 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5417 var snapshot bytes.Buffer 5418 io.Copy(&snapshot, ringBuffer) 5419 err = &smithy.DeserializationError{ 5420 Err: fmt.Errorf("failed to decode response body, %w", err), 5421 Snapshot: snapshot.Bytes(), 5422 } 5423 return err 5424 } 5425 5426 output := &types.PipelineNotFoundException{} 5427 err := awsAwsjson11_deserializeDocumentPipelineNotFoundException(&output, shape) 5428 5429 if err != nil { 5430 var snapshot bytes.Buffer 5431 io.Copy(&snapshot, ringBuffer) 5432 err = &smithy.DeserializationError{ 5433 Err: fmt.Errorf("failed to decode response body, %w", err), 5434 Snapshot: snapshot.Bytes(), 5435 } 5436 return err 5437 } 5438 5439 errorBody.Seek(0, io.SeekStart) 5440 return output 5441} 5442 5443func awsAwsjson11_deserializeErrorPipelineVersionNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5444 var buff [1024]byte 5445 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5446 5447 body := io.TeeReader(errorBody, ringBuffer) 5448 decoder := json.NewDecoder(body) 5449 decoder.UseNumber() 5450 var shape interface{} 5451 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5452 var snapshot bytes.Buffer 5453 io.Copy(&snapshot, ringBuffer) 5454 err = &smithy.DeserializationError{ 5455 Err: fmt.Errorf("failed to decode response body, %w", err), 5456 Snapshot: snapshot.Bytes(), 5457 } 5458 return err 5459 } 5460 5461 output := &types.PipelineVersionNotFoundException{} 5462 err := awsAwsjson11_deserializeDocumentPipelineVersionNotFoundException(&output, shape) 5463 5464 if err != nil { 5465 var snapshot bytes.Buffer 5466 io.Copy(&snapshot, ringBuffer) 5467 err = &smithy.DeserializationError{ 5468 Err: fmt.Errorf("failed to decode response body, %w", err), 5469 Snapshot: snapshot.Bytes(), 5470 } 5471 return err 5472 } 5473 5474 errorBody.Seek(0, io.SeekStart) 5475 return output 5476} 5477 5478func awsAwsjson11_deserializeErrorRequestFailedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5479 var buff [1024]byte 5480 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5481 5482 body := io.TeeReader(errorBody, ringBuffer) 5483 decoder := json.NewDecoder(body) 5484 decoder.UseNumber() 5485 var shape interface{} 5486 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5487 var snapshot bytes.Buffer 5488 io.Copy(&snapshot, ringBuffer) 5489 err = &smithy.DeserializationError{ 5490 Err: fmt.Errorf("failed to decode response body, %w", err), 5491 Snapshot: snapshot.Bytes(), 5492 } 5493 return err 5494 } 5495 5496 output := &types.RequestFailedException{} 5497 err := awsAwsjson11_deserializeDocumentRequestFailedException(&output, shape) 5498 5499 if err != nil { 5500 var snapshot bytes.Buffer 5501 io.Copy(&snapshot, ringBuffer) 5502 err = &smithy.DeserializationError{ 5503 Err: fmt.Errorf("failed to decode response body, %w", err), 5504 Snapshot: snapshot.Bytes(), 5505 } 5506 return err 5507 } 5508 5509 errorBody.Seek(0, io.SeekStart) 5510 return output 5511} 5512 5513func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5514 var buff [1024]byte 5515 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5516 5517 body := io.TeeReader(errorBody, ringBuffer) 5518 decoder := json.NewDecoder(body) 5519 decoder.UseNumber() 5520 var shape interface{} 5521 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5522 var snapshot bytes.Buffer 5523 io.Copy(&snapshot, ringBuffer) 5524 err = &smithy.DeserializationError{ 5525 Err: fmt.Errorf("failed to decode response body, %w", err), 5526 Snapshot: snapshot.Bytes(), 5527 } 5528 return err 5529 } 5530 5531 output := &types.ResourceNotFoundException{} 5532 err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape) 5533 5534 if err != nil { 5535 var snapshot bytes.Buffer 5536 io.Copy(&snapshot, ringBuffer) 5537 err = &smithy.DeserializationError{ 5538 Err: fmt.Errorf("failed to decode response body, %w", err), 5539 Snapshot: snapshot.Bytes(), 5540 } 5541 return err 5542 } 5543 5544 errorBody.Seek(0, io.SeekStart) 5545 return output 5546} 5547 5548func awsAwsjson11_deserializeErrorStageNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5549 var buff [1024]byte 5550 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5551 5552 body := io.TeeReader(errorBody, ringBuffer) 5553 decoder := json.NewDecoder(body) 5554 decoder.UseNumber() 5555 var shape interface{} 5556 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5557 var snapshot bytes.Buffer 5558 io.Copy(&snapshot, ringBuffer) 5559 err = &smithy.DeserializationError{ 5560 Err: fmt.Errorf("failed to decode response body, %w", err), 5561 Snapshot: snapshot.Bytes(), 5562 } 5563 return err 5564 } 5565 5566 output := &types.StageNotFoundException{} 5567 err := awsAwsjson11_deserializeDocumentStageNotFoundException(&output, shape) 5568 5569 if err != nil { 5570 var snapshot bytes.Buffer 5571 io.Copy(&snapshot, ringBuffer) 5572 err = &smithy.DeserializationError{ 5573 Err: fmt.Errorf("failed to decode response body, %w", err), 5574 Snapshot: snapshot.Bytes(), 5575 } 5576 return err 5577 } 5578 5579 errorBody.Seek(0, io.SeekStart) 5580 return output 5581} 5582 5583func awsAwsjson11_deserializeErrorStageNotRetryableException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5584 var buff [1024]byte 5585 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5586 5587 body := io.TeeReader(errorBody, ringBuffer) 5588 decoder := json.NewDecoder(body) 5589 decoder.UseNumber() 5590 var shape interface{} 5591 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5592 var snapshot bytes.Buffer 5593 io.Copy(&snapshot, ringBuffer) 5594 err = &smithy.DeserializationError{ 5595 Err: fmt.Errorf("failed to decode response body, %w", err), 5596 Snapshot: snapshot.Bytes(), 5597 } 5598 return err 5599 } 5600 5601 output := &types.StageNotRetryableException{} 5602 err := awsAwsjson11_deserializeDocumentStageNotRetryableException(&output, shape) 5603 5604 if err != nil { 5605 var snapshot bytes.Buffer 5606 io.Copy(&snapshot, ringBuffer) 5607 err = &smithy.DeserializationError{ 5608 Err: fmt.Errorf("failed to decode response body, %w", err), 5609 Snapshot: snapshot.Bytes(), 5610 } 5611 return err 5612 } 5613 5614 errorBody.Seek(0, io.SeekStart) 5615 return output 5616} 5617 5618func awsAwsjson11_deserializeErrorTooManyTagsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5619 var buff [1024]byte 5620 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5621 5622 body := io.TeeReader(errorBody, ringBuffer) 5623 decoder := json.NewDecoder(body) 5624 decoder.UseNumber() 5625 var shape interface{} 5626 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5627 var snapshot bytes.Buffer 5628 io.Copy(&snapshot, ringBuffer) 5629 err = &smithy.DeserializationError{ 5630 Err: fmt.Errorf("failed to decode response body, %w", err), 5631 Snapshot: snapshot.Bytes(), 5632 } 5633 return err 5634 } 5635 5636 output := &types.TooManyTagsException{} 5637 err := awsAwsjson11_deserializeDocumentTooManyTagsException(&output, shape) 5638 5639 if err != nil { 5640 var snapshot bytes.Buffer 5641 io.Copy(&snapshot, ringBuffer) 5642 err = &smithy.DeserializationError{ 5643 Err: fmt.Errorf("failed to decode response body, %w", err), 5644 Snapshot: snapshot.Bytes(), 5645 } 5646 return err 5647 } 5648 5649 errorBody.Seek(0, io.SeekStart) 5650 return output 5651} 5652 5653func awsAwsjson11_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5654 var buff [1024]byte 5655 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5656 5657 body := io.TeeReader(errorBody, ringBuffer) 5658 decoder := json.NewDecoder(body) 5659 decoder.UseNumber() 5660 var shape interface{} 5661 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5662 var snapshot bytes.Buffer 5663 io.Copy(&snapshot, ringBuffer) 5664 err = &smithy.DeserializationError{ 5665 Err: fmt.Errorf("failed to decode response body, %w", err), 5666 Snapshot: snapshot.Bytes(), 5667 } 5668 return err 5669 } 5670 5671 output := &types.ValidationException{} 5672 err := awsAwsjson11_deserializeDocumentValidationException(&output, shape) 5673 5674 if err != nil { 5675 var snapshot bytes.Buffer 5676 io.Copy(&snapshot, ringBuffer) 5677 err = &smithy.DeserializationError{ 5678 Err: fmt.Errorf("failed to decode response body, %w", err), 5679 Snapshot: snapshot.Bytes(), 5680 } 5681 return err 5682 } 5683 5684 errorBody.Seek(0, io.SeekStart) 5685 return output 5686} 5687 5688func awsAwsjson11_deserializeErrorWebhookNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5689 var buff [1024]byte 5690 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5691 5692 body := io.TeeReader(errorBody, ringBuffer) 5693 decoder := json.NewDecoder(body) 5694 decoder.UseNumber() 5695 var shape interface{} 5696 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5697 var snapshot bytes.Buffer 5698 io.Copy(&snapshot, ringBuffer) 5699 err = &smithy.DeserializationError{ 5700 Err: fmt.Errorf("failed to decode response body, %w", err), 5701 Snapshot: snapshot.Bytes(), 5702 } 5703 return err 5704 } 5705 5706 output := &types.WebhookNotFoundException{} 5707 err := awsAwsjson11_deserializeDocumentWebhookNotFoundException(&output, shape) 5708 5709 if err != nil { 5710 var snapshot bytes.Buffer 5711 io.Copy(&snapshot, ringBuffer) 5712 err = &smithy.DeserializationError{ 5713 Err: fmt.Errorf("failed to decode response body, %w", err), 5714 Snapshot: snapshot.Bytes(), 5715 } 5716 return err 5717 } 5718 5719 errorBody.Seek(0, io.SeekStart) 5720 return output 5721} 5722 5723func awsAwsjson11_deserializeDocumentActionConfiguration(v **types.ActionConfiguration, value interface{}) error { 5724 if v == nil { 5725 return fmt.Errorf("unexpected nil of type %T", v) 5726 } 5727 if value == nil { 5728 return nil 5729 } 5730 5731 shape, ok := value.(map[string]interface{}) 5732 if !ok { 5733 return fmt.Errorf("unexpected JSON type %v", value) 5734 } 5735 5736 var sv *types.ActionConfiguration 5737 if *v == nil { 5738 sv = &types.ActionConfiguration{} 5739 } else { 5740 sv = *v 5741 } 5742 5743 for key, value := range shape { 5744 switch key { 5745 case "configuration": 5746 if err := awsAwsjson11_deserializeDocumentActionConfigurationMap(&sv.Configuration, value); err != nil { 5747 return err 5748 } 5749 5750 default: 5751 _, _ = key, value 5752 5753 } 5754 } 5755 *v = sv 5756 return nil 5757} 5758 5759func awsAwsjson11_deserializeDocumentActionConfigurationMap(v *map[string]string, value interface{}) error { 5760 if v == nil { 5761 return fmt.Errorf("unexpected nil of type %T", v) 5762 } 5763 if value == nil { 5764 return nil 5765 } 5766 5767 shape, ok := value.(map[string]interface{}) 5768 if !ok { 5769 return fmt.Errorf("unexpected JSON type %v", value) 5770 } 5771 5772 var mv map[string]string 5773 if *v == nil { 5774 mv = map[string]string{} 5775 } else { 5776 mv = *v 5777 } 5778 5779 for key, value := range shape { 5780 var parsedVal string 5781 if value != nil { 5782 jtv, ok := value.(string) 5783 if !ok { 5784 return fmt.Errorf("expected ActionConfigurationValue to be of type string, got %T instead", value) 5785 } 5786 parsedVal = jtv 5787 } 5788 mv[key] = parsedVal 5789 5790 } 5791 *v = mv 5792 return nil 5793} 5794 5795func awsAwsjson11_deserializeDocumentActionConfigurationProperty(v **types.ActionConfigurationProperty, value interface{}) error { 5796 if v == nil { 5797 return fmt.Errorf("unexpected nil of type %T", v) 5798 } 5799 if value == nil { 5800 return nil 5801 } 5802 5803 shape, ok := value.(map[string]interface{}) 5804 if !ok { 5805 return fmt.Errorf("unexpected JSON type %v", value) 5806 } 5807 5808 var sv *types.ActionConfigurationProperty 5809 if *v == nil { 5810 sv = &types.ActionConfigurationProperty{} 5811 } else { 5812 sv = *v 5813 } 5814 5815 for key, value := range shape { 5816 switch key { 5817 case "description": 5818 if value != nil { 5819 jtv, ok := value.(string) 5820 if !ok { 5821 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 5822 } 5823 sv.Description = ptr.String(jtv) 5824 } 5825 5826 case "key": 5827 if value != nil { 5828 jtv, ok := value.(bool) 5829 if !ok { 5830 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5831 } 5832 sv.Key = jtv 5833 } 5834 5835 case "name": 5836 if value != nil { 5837 jtv, ok := value.(string) 5838 if !ok { 5839 return fmt.Errorf("expected ActionConfigurationKey to be of type string, got %T instead", value) 5840 } 5841 sv.Name = ptr.String(jtv) 5842 } 5843 5844 case "queryable": 5845 if value != nil { 5846 jtv, ok := value.(bool) 5847 if !ok { 5848 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5849 } 5850 sv.Queryable = jtv 5851 } 5852 5853 case "required": 5854 if value != nil { 5855 jtv, ok := value.(bool) 5856 if !ok { 5857 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5858 } 5859 sv.Required = jtv 5860 } 5861 5862 case "secret": 5863 if value != nil { 5864 jtv, ok := value.(bool) 5865 if !ok { 5866 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5867 } 5868 sv.Secret = jtv 5869 } 5870 5871 case "type": 5872 if value != nil { 5873 jtv, ok := value.(string) 5874 if !ok { 5875 return fmt.Errorf("expected ActionConfigurationPropertyType to be of type string, got %T instead", value) 5876 } 5877 sv.Type = types.ActionConfigurationPropertyType(jtv) 5878 } 5879 5880 default: 5881 _, _ = key, value 5882 5883 } 5884 } 5885 *v = sv 5886 return nil 5887} 5888 5889func awsAwsjson11_deserializeDocumentActionConfigurationPropertyList(v *[]types.ActionConfigurationProperty, value interface{}) error { 5890 if v == nil { 5891 return fmt.Errorf("unexpected nil of type %T", v) 5892 } 5893 if value == nil { 5894 return nil 5895 } 5896 5897 shape, ok := value.([]interface{}) 5898 if !ok { 5899 return fmt.Errorf("unexpected JSON type %v", value) 5900 } 5901 5902 var cv []types.ActionConfigurationProperty 5903 if *v == nil { 5904 cv = []types.ActionConfigurationProperty{} 5905 } else { 5906 cv = *v 5907 } 5908 5909 for _, value := range shape { 5910 var col types.ActionConfigurationProperty 5911 destAddr := &col 5912 if err := awsAwsjson11_deserializeDocumentActionConfigurationProperty(&destAddr, value); err != nil { 5913 return err 5914 } 5915 col = *destAddr 5916 cv = append(cv, col) 5917 5918 } 5919 *v = cv 5920 return nil 5921} 5922 5923func awsAwsjson11_deserializeDocumentActionContext(v **types.ActionContext, value interface{}) error { 5924 if v == nil { 5925 return fmt.Errorf("unexpected nil of type %T", v) 5926 } 5927 if value == nil { 5928 return nil 5929 } 5930 5931 shape, ok := value.(map[string]interface{}) 5932 if !ok { 5933 return fmt.Errorf("unexpected JSON type %v", value) 5934 } 5935 5936 var sv *types.ActionContext 5937 if *v == nil { 5938 sv = &types.ActionContext{} 5939 } else { 5940 sv = *v 5941 } 5942 5943 for key, value := range shape { 5944 switch key { 5945 case "actionExecutionId": 5946 if value != nil { 5947 jtv, ok := value.(string) 5948 if !ok { 5949 return fmt.Errorf("expected ActionExecutionId to be of type string, got %T instead", value) 5950 } 5951 sv.ActionExecutionId = ptr.String(jtv) 5952 } 5953 5954 case "name": 5955 if value != nil { 5956 jtv, ok := value.(string) 5957 if !ok { 5958 return fmt.Errorf("expected ActionName to be of type string, got %T instead", value) 5959 } 5960 sv.Name = ptr.String(jtv) 5961 } 5962 5963 default: 5964 _, _ = key, value 5965 5966 } 5967 } 5968 *v = sv 5969 return nil 5970} 5971 5972func awsAwsjson11_deserializeDocumentActionDeclaration(v **types.ActionDeclaration, value interface{}) error { 5973 if v == nil { 5974 return fmt.Errorf("unexpected nil of type %T", v) 5975 } 5976 if value == nil { 5977 return nil 5978 } 5979 5980 shape, ok := value.(map[string]interface{}) 5981 if !ok { 5982 return fmt.Errorf("unexpected JSON type %v", value) 5983 } 5984 5985 var sv *types.ActionDeclaration 5986 if *v == nil { 5987 sv = &types.ActionDeclaration{} 5988 } else { 5989 sv = *v 5990 } 5991 5992 for key, value := range shape { 5993 switch key { 5994 case "actionTypeId": 5995 if err := awsAwsjson11_deserializeDocumentActionTypeId(&sv.ActionTypeId, value); err != nil { 5996 return err 5997 } 5998 5999 case "configuration": 6000 if err := awsAwsjson11_deserializeDocumentActionConfigurationMap(&sv.Configuration, value); err != nil { 6001 return err 6002 } 6003 6004 case "inputArtifacts": 6005 if err := awsAwsjson11_deserializeDocumentInputArtifactList(&sv.InputArtifacts, value); err != nil { 6006 return err 6007 } 6008 6009 case "name": 6010 if value != nil { 6011 jtv, ok := value.(string) 6012 if !ok { 6013 return fmt.Errorf("expected ActionName to be of type string, got %T instead", value) 6014 } 6015 sv.Name = ptr.String(jtv) 6016 } 6017 6018 case "namespace": 6019 if value != nil { 6020 jtv, ok := value.(string) 6021 if !ok { 6022 return fmt.Errorf("expected ActionNamespace to be of type string, got %T instead", value) 6023 } 6024 sv.Namespace = ptr.String(jtv) 6025 } 6026 6027 case "outputArtifacts": 6028 if err := awsAwsjson11_deserializeDocumentOutputArtifactList(&sv.OutputArtifacts, value); err != nil { 6029 return err 6030 } 6031 6032 case "region": 6033 if value != nil { 6034 jtv, ok := value.(string) 6035 if !ok { 6036 return fmt.Errorf("expected AWSRegionName to be of type string, got %T instead", value) 6037 } 6038 sv.Region = ptr.String(jtv) 6039 } 6040 6041 case "roleArn": 6042 if value != nil { 6043 jtv, ok := value.(string) 6044 if !ok { 6045 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 6046 } 6047 sv.RoleArn = ptr.String(jtv) 6048 } 6049 6050 case "runOrder": 6051 if value != nil { 6052 jtv, ok := value.(json.Number) 6053 if !ok { 6054 return fmt.Errorf("expected ActionRunOrder to be json.Number, got %T instead", value) 6055 } 6056 i64, err := jtv.Int64() 6057 if err != nil { 6058 return err 6059 } 6060 sv.RunOrder = ptr.Int32(int32(i64)) 6061 } 6062 6063 default: 6064 _, _ = key, value 6065 6066 } 6067 } 6068 *v = sv 6069 return nil 6070} 6071 6072func awsAwsjson11_deserializeDocumentActionExecution(v **types.ActionExecution, value interface{}) error { 6073 if v == nil { 6074 return fmt.Errorf("unexpected nil of type %T", v) 6075 } 6076 if value == nil { 6077 return nil 6078 } 6079 6080 shape, ok := value.(map[string]interface{}) 6081 if !ok { 6082 return fmt.Errorf("unexpected JSON type %v", value) 6083 } 6084 6085 var sv *types.ActionExecution 6086 if *v == nil { 6087 sv = &types.ActionExecution{} 6088 } else { 6089 sv = *v 6090 } 6091 6092 for key, value := range shape { 6093 switch key { 6094 case "actionExecutionId": 6095 if value != nil { 6096 jtv, ok := value.(string) 6097 if !ok { 6098 return fmt.Errorf("expected ActionExecutionId to be of type string, got %T instead", value) 6099 } 6100 sv.ActionExecutionId = ptr.String(jtv) 6101 } 6102 6103 case "errorDetails": 6104 if err := awsAwsjson11_deserializeDocumentErrorDetails(&sv.ErrorDetails, value); err != nil { 6105 return err 6106 } 6107 6108 case "externalExecutionId": 6109 if value != nil { 6110 jtv, ok := value.(string) 6111 if !ok { 6112 return fmt.Errorf("expected ExecutionId to be of type string, got %T instead", value) 6113 } 6114 sv.ExternalExecutionId = ptr.String(jtv) 6115 } 6116 6117 case "externalExecutionUrl": 6118 if value != nil { 6119 jtv, ok := value.(string) 6120 if !ok { 6121 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 6122 } 6123 sv.ExternalExecutionUrl = ptr.String(jtv) 6124 } 6125 6126 case "lastStatusChange": 6127 if value != nil { 6128 switch jtv := value.(type) { 6129 case json.Number: 6130 f64, err := jtv.Float64() 6131 if err != nil { 6132 return err 6133 } 6134 sv.LastStatusChange = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6135 6136 default: 6137 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 6138 6139 } 6140 } 6141 6142 case "lastUpdatedBy": 6143 if value != nil { 6144 jtv, ok := value.(string) 6145 if !ok { 6146 return fmt.Errorf("expected LastUpdatedBy to be of type string, got %T instead", value) 6147 } 6148 sv.LastUpdatedBy = ptr.String(jtv) 6149 } 6150 6151 case "percentComplete": 6152 if value != nil { 6153 jtv, ok := value.(json.Number) 6154 if !ok { 6155 return fmt.Errorf("expected Percentage to be json.Number, got %T instead", value) 6156 } 6157 i64, err := jtv.Int64() 6158 if err != nil { 6159 return err 6160 } 6161 sv.PercentComplete = ptr.Int32(int32(i64)) 6162 } 6163 6164 case "status": 6165 if value != nil { 6166 jtv, ok := value.(string) 6167 if !ok { 6168 return fmt.Errorf("expected ActionExecutionStatus to be of type string, got %T instead", value) 6169 } 6170 sv.Status = types.ActionExecutionStatus(jtv) 6171 } 6172 6173 case "summary": 6174 if value != nil { 6175 jtv, ok := value.(string) 6176 if !ok { 6177 return fmt.Errorf("expected ExecutionSummary to be of type string, got %T instead", value) 6178 } 6179 sv.Summary = ptr.String(jtv) 6180 } 6181 6182 case "token": 6183 if value != nil { 6184 jtv, ok := value.(string) 6185 if !ok { 6186 return fmt.Errorf("expected ActionExecutionToken to be of type string, got %T instead", value) 6187 } 6188 sv.Token = ptr.String(jtv) 6189 } 6190 6191 default: 6192 _, _ = key, value 6193 6194 } 6195 } 6196 *v = sv 6197 return nil 6198} 6199 6200func awsAwsjson11_deserializeDocumentActionExecutionDetail(v **types.ActionExecutionDetail, value interface{}) error { 6201 if v == nil { 6202 return fmt.Errorf("unexpected nil of type %T", v) 6203 } 6204 if value == nil { 6205 return nil 6206 } 6207 6208 shape, ok := value.(map[string]interface{}) 6209 if !ok { 6210 return fmt.Errorf("unexpected JSON type %v", value) 6211 } 6212 6213 var sv *types.ActionExecutionDetail 6214 if *v == nil { 6215 sv = &types.ActionExecutionDetail{} 6216 } else { 6217 sv = *v 6218 } 6219 6220 for key, value := range shape { 6221 switch key { 6222 case "actionExecutionId": 6223 if value != nil { 6224 jtv, ok := value.(string) 6225 if !ok { 6226 return fmt.Errorf("expected ActionExecutionId to be of type string, got %T instead", value) 6227 } 6228 sv.ActionExecutionId = ptr.String(jtv) 6229 } 6230 6231 case "actionName": 6232 if value != nil { 6233 jtv, ok := value.(string) 6234 if !ok { 6235 return fmt.Errorf("expected ActionName to be of type string, got %T instead", value) 6236 } 6237 sv.ActionName = ptr.String(jtv) 6238 } 6239 6240 case "input": 6241 if err := awsAwsjson11_deserializeDocumentActionExecutionInput(&sv.Input, value); err != nil { 6242 return err 6243 } 6244 6245 case "lastUpdateTime": 6246 if value != nil { 6247 switch jtv := value.(type) { 6248 case json.Number: 6249 f64, err := jtv.Float64() 6250 if err != nil { 6251 return err 6252 } 6253 sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6254 6255 default: 6256 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 6257 6258 } 6259 } 6260 6261 case "output": 6262 if err := awsAwsjson11_deserializeDocumentActionExecutionOutput(&sv.Output, value); err != nil { 6263 return err 6264 } 6265 6266 case "pipelineExecutionId": 6267 if value != nil { 6268 jtv, ok := value.(string) 6269 if !ok { 6270 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 6271 } 6272 sv.PipelineExecutionId = ptr.String(jtv) 6273 } 6274 6275 case "pipelineVersion": 6276 if value != nil { 6277 jtv, ok := value.(json.Number) 6278 if !ok { 6279 return fmt.Errorf("expected PipelineVersion to be json.Number, got %T instead", value) 6280 } 6281 i64, err := jtv.Int64() 6282 if err != nil { 6283 return err 6284 } 6285 sv.PipelineVersion = ptr.Int32(int32(i64)) 6286 } 6287 6288 case "stageName": 6289 if value != nil { 6290 jtv, ok := value.(string) 6291 if !ok { 6292 return fmt.Errorf("expected StageName to be of type string, got %T instead", value) 6293 } 6294 sv.StageName = ptr.String(jtv) 6295 } 6296 6297 case "startTime": 6298 if value != nil { 6299 switch jtv := value.(type) { 6300 case json.Number: 6301 f64, err := jtv.Float64() 6302 if err != nil { 6303 return err 6304 } 6305 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6306 6307 default: 6308 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 6309 6310 } 6311 } 6312 6313 case "status": 6314 if value != nil { 6315 jtv, ok := value.(string) 6316 if !ok { 6317 return fmt.Errorf("expected ActionExecutionStatus to be of type string, got %T instead", value) 6318 } 6319 sv.Status = types.ActionExecutionStatus(jtv) 6320 } 6321 6322 default: 6323 _, _ = key, value 6324 6325 } 6326 } 6327 *v = sv 6328 return nil 6329} 6330 6331func awsAwsjson11_deserializeDocumentActionExecutionDetailList(v *[]types.ActionExecutionDetail, value interface{}) error { 6332 if v == nil { 6333 return fmt.Errorf("unexpected nil of type %T", v) 6334 } 6335 if value == nil { 6336 return nil 6337 } 6338 6339 shape, ok := value.([]interface{}) 6340 if !ok { 6341 return fmt.Errorf("unexpected JSON type %v", value) 6342 } 6343 6344 var cv []types.ActionExecutionDetail 6345 if *v == nil { 6346 cv = []types.ActionExecutionDetail{} 6347 } else { 6348 cv = *v 6349 } 6350 6351 for _, value := range shape { 6352 var col types.ActionExecutionDetail 6353 destAddr := &col 6354 if err := awsAwsjson11_deserializeDocumentActionExecutionDetail(&destAddr, value); err != nil { 6355 return err 6356 } 6357 col = *destAddr 6358 cv = append(cv, col) 6359 6360 } 6361 *v = cv 6362 return nil 6363} 6364 6365func awsAwsjson11_deserializeDocumentActionExecutionInput(v **types.ActionExecutionInput, value interface{}) error { 6366 if v == nil { 6367 return fmt.Errorf("unexpected nil of type %T", v) 6368 } 6369 if value == nil { 6370 return nil 6371 } 6372 6373 shape, ok := value.(map[string]interface{}) 6374 if !ok { 6375 return fmt.Errorf("unexpected JSON type %v", value) 6376 } 6377 6378 var sv *types.ActionExecutionInput 6379 if *v == nil { 6380 sv = &types.ActionExecutionInput{} 6381 } else { 6382 sv = *v 6383 } 6384 6385 for key, value := range shape { 6386 switch key { 6387 case "actionTypeId": 6388 if err := awsAwsjson11_deserializeDocumentActionTypeId(&sv.ActionTypeId, value); err != nil { 6389 return err 6390 } 6391 6392 case "configuration": 6393 if err := awsAwsjson11_deserializeDocumentActionConfigurationMap(&sv.Configuration, value); err != nil { 6394 return err 6395 } 6396 6397 case "inputArtifacts": 6398 if err := awsAwsjson11_deserializeDocumentArtifactDetailList(&sv.InputArtifacts, value); err != nil { 6399 return err 6400 } 6401 6402 case "namespace": 6403 if value != nil { 6404 jtv, ok := value.(string) 6405 if !ok { 6406 return fmt.Errorf("expected ActionNamespace to be of type string, got %T instead", value) 6407 } 6408 sv.Namespace = ptr.String(jtv) 6409 } 6410 6411 case "region": 6412 if value != nil { 6413 jtv, ok := value.(string) 6414 if !ok { 6415 return fmt.Errorf("expected AWSRegionName to be of type string, got %T instead", value) 6416 } 6417 sv.Region = ptr.String(jtv) 6418 } 6419 6420 case "resolvedConfiguration": 6421 if err := awsAwsjson11_deserializeDocumentResolvedActionConfigurationMap(&sv.ResolvedConfiguration, value); err != nil { 6422 return err 6423 } 6424 6425 case "roleArn": 6426 if value != nil { 6427 jtv, ok := value.(string) 6428 if !ok { 6429 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 6430 } 6431 sv.RoleArn = ptr.String(jtv) 6432 } 6433 6434 default: 6435 _, _ = key, value 6436 6437 } 6438 } 6439 *v = sv 6440 return nil 6441} 6442 6443func awsAwsjson11_deserializeDocumentActionExecutionOutput(v **types.ActionExecutionOutput, value interface{}) error { 6444 if v == nil { 6445 return fmt.Errorf("unexpected nil of type %T", v) 6446 } 6447 if value == nil { 6448 return nil 6449 } 6450 6451 shape, ok := value.(map[string]interface{}) 6452 if !ok { 6453 return fmt.Errorf("unexpected JSON type %v", value) 6454 } 6455 6456 var sv *types.ActionExecutionOutput 6457 if *v == nil { 6458 sv = &types.ActionExecutionOutput{} 6459 } else { 6460 sv = *v 6461 } 6462 6463 for key, value := range shape { 6464 switch key { 6465 case "executionResult": 6466 if err := awsAwsjson11_deserializeDocumentActionExecutionResult(&sv.ExecutionResult, value); err != nil { 6467 return err 6468 } 6469 6470 case "outputArtifacts": 6471 if err := awsAwsjson11_deserializeDocumentArtifactDetailList(&sv.OutputArtifacts, value); err != nil { 6472 return err 6473 } 6474 6475 case "outputVariables": 6476 if err := awsAwsjson11_deserializeDocumentOutputVariablesMap(&sv.OutputVariables, value); err != nil { 6477 return err 6478 } 6479 6480 default: 6481 _, _ = key, value 6482 6483 } 6484 } 6485 *v = sv 6486 return nil 6487} 6488 6489func awsAwsjson11_deserializeDocumentActionExecutionResult(v **types.ActionExecutionResult, value interface{}) error { 6490 if v == nil { 6491 return fmt.Errorf("unexpected nil of type %T", v) 6492 } 6493 if value == nil { 6494 return nil 6495 } 6496 6497 shape, ok := value.(map[string]interface{}) 6498 if !ok { 6499 return fmt.Errorf("unexpected JSON type %v", value) 6500 } 6501 6502 var sv *types.ActionExecutionResult 6503 if *v == nil { 6504 sv = &types.ActionExecutionResult{} 6505 } else { 6506 sv = *v 6507 } 6508 6509 for key, value := range shape { 6510 switch key { 6511 case "externalExecutionId": 6512 if value != nil { 6513 jtv, ok := value.(string) 6514 if !ok { 6515 return fmt.Errorf("expected ExternalExecutionId to be of type string, got %T instead", value) 6516 } 6517 sv.ExternalExecutionId = ptr.String(jtv) 6518 } 6519 6520 case "externalExecutionSummary": 6521 if value != nil { 6522 jtv, ok := value.(string) 6523 if !ok { 6524 return fmt.Errorf("expected ExternalExecutionSummary to be of type string, got %T instead", value) 6525 } 6526 sv.ExternalExecutionSummary = ptr.String(jtv) 6527 } 6528 6529 case "externalExecutionUrl": 6530 if value != nil { 6531 jtv, ok := value.(string) 6532 if !ok { 6533 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 6534 } 6535 sv.ExternalExecutionUrl = ptr.String(jtv) 6536 } 6537 6538 default: 6539 _, _ = key, value 6540 6541 } 6542 } 6543 *v = sv 6544 return nil 6545} 6546 6547func awsAwsjson11_deserializeDocumentActionNotFoundException(v **types.ActionNotFoundException, value interface{}) error { 6548 if v == nil { 6549 return fmt.Errorf("unexpected nil of type %T", v) 6550 } 6551 if value == nil { 6552 return nil 6553 } 6554 6555 shape, ok := value.(map[string]interface{}) 6556 if !ok { 6557 return fmt.Errorf("unexpected JSON type %v", value) 6558 } 6559 6560 var sv *types.ActionNotFoundException 6561 if *v == nil { 6562 sv = &types.ActionNotFoundException{} 6563 } else { 6564 sv = *v 6565 } 6566 6567 for key, value := range shape { 6568 switch key { 6569 case "message": 6570 if value != nil { 6571 jtv, ok := value.(string) 6572 if !ok { 6573 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 6574 } 6575 sv.Message = ptr.String(jtv) 6576 } 6577 6578 default: 6579 _, _ = key, value 6580 6581 } 6582 } 6583 *v = sv 6584 return nil 6585} 6586 6587func awsAwsjson11_deserializeDocumentActionRevision(v **types.ActionRevision, value interface{}) error { 6588 if v == nil { 6589 return fmt.Errorf("unexpected nil of type %T", v) 6590 } 6591 if value == nil { 6592 return nil 6593 } 6594 6595 shape, ok := value.(map[string]interface{}) 6596 if !ok { 6597 return fmt.Errorf("unexpected JSON type %v", value) 6598 } 6599 6600 var sv *types.ActionRevision 6601 if *v == nil { 6602 sv = &types.ActionRevision{} 6603 } else { 6604 sv = *v 6605 } 6606 6607 for key, value := range shape { 6608 switch key { 6609 case "created": 6610 if value != nil { 6611 switch jtv := value.(type) { 6612 case json.Number: 6613 f64, err := jtv.Float64() 6614 if err != nil { 6615 return err 6616 } 6617 sv.Created = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6618 6619 default: 6620 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 6621 6622 } 6623 } 6624 6625 case "revisionChangeId": 6626 if value != nil { 6627 jtv, ok := value.(string) 6628 if !ok { 6629 return fmt.Errorf("expected RevisionChangeIdentifier to be of type string, got %T instead", value) 6630 } 6631 sv.RevisionChangeId = ptr.String(jtv) 6632 } 6633 6634 case "revisionId": 6635 if value != nil { 6636 jtv, ok := value.(string) 6637 if !ok { 6638 return fmt.Errorf("expected Revision to be of type string, got %T instead", value) 6639 } 6640 sv.RevisionId = ptr.String(jtv) 6641 } 6642 6643 default: 6644 _, _ = key, value 6645 6646 } 6647 } 6648 *v = sv 6649 return nil 6650} 6651 6652func awsAwsjson11_deserializeDocumentActionState(v **types.ActionState, value interface{}) error { 6653 if v == nil { 6654 return fmt.Errorf("unexpected nil of type %T", v) 6655 } 6656 if value == nil { 6657 return nil 6658 } 6659 6660 shape, ok := value.(map[string]interface{}) 6661 if !ok { 6662 return fmt.Errorf("unexpected JSON type %v", value) 6663 } 6664 6665 var sv *types.ActionState 6666 if *v == nil { 6667 sv = &types.ActionState{} 6668 } else { 6669 sv = *v 6670 } 6671 6672 for key, value := range shape { 6673 switch key { 6674 case "actionName": 6675 if value != nil { 6676 jtv, ok := value.(string) 6677 if !ok { 6678 return fmt.Errorf("expected ActionName to be of type string, got %T instead", value) 6679 } 6680 sv.ActionName = ptr.String(jtv) 6681 } 6682 6683 case "currentRevision": 6684 if err := awsAwsjson11_deserializeDocumentActionRevision(&sv.CurrentRevision, value); err != nil { 6685 return err 6686 } 6687 6688 case "entityUrl": 6689 if value != nil { 6690 jtv, ok := value.(string) 6691 if !ok { 6692 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 6693 } 6694 sv.EntityUrl = ptr.String(jtv) 6695 } 6696 6697 case "latestExecution": 6698 if err := awsAwsjson11_deserializeDocumentActionExecution(&sv.LatestExecution, value); err != nil { 6699 return err 6700 } 6701 6702 case "revisionUrl": 6703 if value != nil { 6704 jtv, ok := value.(string) 6705 if !ok { 6706 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 6707 } 6708 sv.RevisionUrl = ptr.String(jtv) 6709 } 6710 6711 default: 6712 _, _ = key, value 6713 6714 } 6715 } 6716 *v = sv 6717 return nil 6718} 6719 6720func awsAwsjson11_deserializeDocumentActionStateList(v *[]types.ActionState, value interface{}) error { 6721 if v == nil { 6722 return fmt.Errorf("unexpected nil of type %T", v) 6723 } 6724 if value == nil { 6725 return nil 6726 } 6727 6728 shape, ok := value.([]interface{}) 6729 if !ok { 6730 return fmt.Errorf("unexpected JSON type %v", value) 6731 } 6732 6733 var cv []types.ActionState 6734 if *v == nil { 6735 cv = []types.ActionState{} 6736 } else { 6737 cv = *v 6738 } 6739 6740 for _, value := range shape { 6741 var col types.ActionState 6742 destAddr := &col 6743 if err := awsAwsjson11_deserializeDocumentActionState(&destAddr, value); err != nil { 6744 return err 6745 } 6746 col = *destAddr 6747 cv = append(cv, col) 6748 6749 } 6750 *v = cv 6751 return nil 6752} 6753 6754func awsAwsjson11_deserializeDocumentActionType(v **types.ActionType, value interface{}) error { 6755 if v == nil { 6756 return fmt.Errorf("unexpected nil of type %T", v) 6757 } 6758 if value == nil { 6759 return nil 6760 } 6761 6762 shape, ok := value.(map[string]interface{}) 6763 if !ok { 6764 return fmt.Errorf("unexpected JSON type %v", value) 6765 } 6766 6767 var sv *types.ActionType 6768 if *v == nil { 6769 sv = &types.ActionType{} 6770 } else { 6771 sv = *v 6772 } 6773 6774 for key, value := range shape { 6775 switch key { 6776 case "actionConfigurationProperties": 6777 if err := awsAwsjson11_deserializeDocumentActionConfigurationPropertyList(&sv.ActionConfigurationProperties, value); err != nil { 6778 return err 6779 } 6780 6781 case "id": 6782 if err := awsAwsjson11_deserializeDocumentActionTypeId(&sv.Id, value); err != nil { 6783 return err 6784 } 6785 6786 case "inputArtifactDetails": 6787 if err := awsAwsjson11_deserializeDocumentArtifactDetails(&sv.InputArtifactDetails, value); err != nil { 6788 return err 6789 } 6790 6791 case "outputArtifactDetails": 6792 if err := awsAwsjson11_deserializeDocumentArtifactDetails(&sv.OutputArtifactDetails, value); err != nil { 6793 return err 6794 } 6795 6796 case "settings": 6797 if err := awsAwsjson11_deserializeDocumentActionTypeSettings(&sv.Settings, value); err != nil { 6798 return err 6799 } 6800 6801 default: 6802 _, _ = key, value 6803 6804 } 6805 } 6806 *v = sv 6807 return nil 6808} 6809 6810func awsAwsjson11_deserializeDocumentActionTypeArtifactDetails(v **types.ActionTypeArtifactDetails, value interface{}) error { 6811 if v == nil { 6812 return fmt.Errorf("unexpected nil of type %T", v) 6813 } 6814 if value == nil { 6815 return nil 6816 } 6817 6818 shape, ok := value.(map[string]interface{}) 6819 if !ok { 6820 return fmt.Errorf("unexpected JSON type %v", value) 6821 } 6822 6823 var sv *types.ActionTypeArtifactDetails 6824 if *v == nil { 6825 sv = &types.ActionTypeArtifactDetails{} 6826 } else { 6827 sv = *v 6828 } 6829 6830 for key, value := range shape { 6831 switch key { 6832 case "maximumCount": 6833 if value != nil { 6834 jtv, ok := value.(json.Number) 6835 if !ok { 6836 return fmt.Errorf("expected MaximumActionTypeArtifactCount to be json.Number, got %T instead", value) 6837 } 6838 i64, err := jtv.Int64() 6839 if err != nil { 6840 return err 6841 } 6842 sv.MaximumCount = int32(i64) 6843 } 6844 6845 case "minimumCount": 6846 if value != nil { 6847 jtv, ok := value.(json.Number) 6848 if !ok { 6849 return fmt.Errorf("expected MinimumActionTypeArtifactCount to be json.Number, got %T instead", value) 6850 } 6851 i64, err := jtv.Int64() 6852 if err != nil { 6853 return err 6854 } 6855 sv.MinimumCount = int32(i64) 6856 } 6857 6858 default: 6859 _, _ = key, value 6860 6861 } 6862 } 6863 *v = sv 6864 return nil 6865} 6866 6867func awsAwsjson11_deserializeDocumentActionTypeDeclaration(v **types.ActionTypeDeclaration, value interface{}) error { 6868 if v == nil { 6869 return fmt.Errorf("unexpected nil of type %T", v) 6870 } 6871 if value == nil { 6872 return nil 6873 } 6874 6875 shape, ok := value.(map[string]interface{}) 6876 if !ok { 6877 return fmt.Errorf("unexpected JSON type %v", value) 6878 } 6879 6880 var sv *types.ActionTypeDeclaration 6881 if *v == nil { 6882 sv = &types.ActionTypeDeclaration{} 6883 } else { 6884 sv = *v 6885 } 6886 6887 for key, value := range shape { 6888 switch key { 6889 case "description": 6890 if value != nil { 6891 jtv, ok := value.(string) 6892 if !ok { 6893 return fmt.Errorf("expected ActionTypeDescription to be of type string, got %T instead", value) 6894 } 6895 sv.Description = ptr.String(jtv) 6896 } 6897 6898 case "executor": 6899 if err := awsAwsjson11_deserializeDocumentActionTypeExecutor(&sv.Executor, value); err != nil { 6900 return err 6901 } 6902 6903 case "id": 6904 if err := awsAwsjson11_deserializeDocumentActionTypeIdentifier(&sv.Id, value); err != nil { 6905 return err 6906 } 6907 6908 case "inputArtifactDetails": 6909 if err := awsAwsjson11_deserializeDocumentActionTypeArtifactDetails(&sv.InputArtifactDetails, value); err != nil { 6910 return err 6911 } 6912 6913 case "outputArtifactDetails": 6914 if err := awsAwsjson11_deserializeDocumentActionTypeArtifactDetails(&sv.OutputArtifactDetails, value); err != nil { 6915 return err 6916 } 6917 6918 case "permissions": 6919 if err := awsAwsjson11_deserializeDocumentActionTypePermissions(&sv.Permissions, value); err != nil { 6920 return err 6921 } 6922 6923 case "properties": 6924 if err := awsAwsjson11_deserializeDocumentActionTypeProperties(&sv.Properties, value); err != nil { 6925 return err 6926 } 6927 6928 case "urls": 6929 if err := awsAwsjson11_deserializeDocumentActionTypeUrls(&sv.Urls, value); err != nil { 6930 return err 6931 } 6932 6933 default: 6934 _, _ = key, value 6935 6936 } 6937 } 6938 *v = sv 6939 return nil 6940} 6941 6942func awsAwsjson11_deserializeDocumentActionTypeExecutor(v **types.ActionTypeExecutor, value interface{}) error { 6943 if v == nil { 6944 return fmt.Errorf("unexpected nil of type %T", v) 6945 } 6946 if value == nil { 6947 return nil 6948 } 6949 6950 shape, ok := value.(map[string]interface{}) 6951 if !ok { 6952 return fmt.Errorf("unexpected JSON type %v", value) 6953 } 6954 6955 var sv *types.ActionTypeExecutor 6956 if *v == nil { 6957 sv = &types.ActionTypeExecutor{} 6958 } else { 6959 sv = *v 6960 } 6961 6962 for key, value := range shape { 6963 switch key { 6964 case "configuration": 6965 if err := awsAwsjson11_deserializeDocumentExecutorConfiguration(&sv.Configuration, value); err != nil { 6966 return err 6967 } 6968 6969 case "jobTimeout": 6970 if value != nil { 6971 jtv, ok := value.(json.Number) 6972 if !ok { 6973 return fmt.Errorf("expected JobTimeout to be json.Number, got %T instead", value) 6974 } 6975 i64, err := jtv.Int64() 6976 if err != nil { 6977 return err 6978 } 6979 sv.JobTimeout = ptr.Int32(int32(i64)) 6980 } 6981 6982 case "policyStatementsTemplate": 6983 if value != nil { 6984 jtv, ok := value.(string) 6985 if !ok { 6986 return fmt.Errorf("expected PolicyStatementsTemplate to be of type string, got %T instead", value) 6987 } 6988 sv.PolicyStatementsTemplate = ptr.String(jtv) 6989 } 6990 6991 case "type": 6992 if value != nil { 6993 jtv, ok := value.(string) 6994 if !ok { 6995 return fmt.Errorf("expected ExecutorType to be of type string, got %T instead", value) 6996 } 6997 sv.Type = types.ExecutorType(jtv) 6998 } 6999 7000 default: 7001 _, _ = key, value 7002 7003 } 7004 } 7005 *v = sv 7006 return nil 7007} 7008 7009func awsAwsjson11_deserializeDocumentActionTypeId(v **types.ActionTypeId, value interface{}) error { 7010 if v == nil { 7011 return fmt.Errorf("unexpected nil of type %T", v) 7012 } 7013 if value == nil { 7014 return nil 7015 } 7016 7017 shape, ok := value.(map[string]interface{}) 7018 if !ok { 7019 return fmt.Errorf("unexpected JSON type %v", value) 7020 } 7021 7022 var sv *types.ActionTypeId 7023 if *v == nil { 7024 sv = &types.ActionTypeId{} 7025 } else { 7026 sv = *v 7027 } 7028 7029 for key, value := range shape { 7030 switch key { 7031 case "category": 7032 if value != nil { 7033 jtv, ok := value.(string) 7034 if !ok { 7035 return fmt.Errorf("expected ActionCategory to be of type string, got %T instead", value) 7036 } 7037 sv.Category = types.ActionCategory(jtv) 7038 } 7039 7040 case "owner": 7041 if value != nil { 7042 jtv, ok := value.(string) 7043 if !ok { 7044 return fmt.Errorf("expected ActionOwner to be of type string, got %T instead", value) 7045 } 7046 sv.Owner = types.ActionOwner(jtv) 7047 } 7048 7049 case "provider": 7050 if value != nil { 7051 jtv, ok := value.(string) 7052 if !ok { 7053 return fmt.Errorf("expected ActionProvider to be of type string, got %T instead", value) 7054 } 7055 sv.Provider = ptr.String(jtv) 7056 } 7057 7058 case "version": 7059 if value != nil { 7060 jtv, ok := value.(string) 7061 if !ok { 7062 return fmt.Errorf("expected Version to be of type string, got %T instead", value) 7063 } 7064 sv.Version = ptr.String(jtv) 7065 } 7066 7067 default: 7068 _, _ = key, value 7069 7070 } 7071 } 7072 *v = sv 7073 return nil 7074} 7075 7076func awsAwsjson11_deserializeDocumentActionTypeIdentifier(v **types.ActionTypeIdentifier, value interface{}) error { 7077 if v == nil { 7078 return fmt.Errorf("unexpected nil of type %T", v) 7079 } 7080 if value == nil { 7081 return nil 7082 } 7083 7084 shape, ok := value.(map[string]interface{}) 7085 if !ok { 7086 return fmt.Errorf("unexpected JSON type %v", value) 7087 } 7088 7089 var sv *types.ActionTypeIdentifier 7090 if *v == nil { 7091 sv = &types.ActionTypeIdentifier{} 7092 } else { 7093 sv = *v 7094 } 7095 7096 for key, value := range shape { 7097 switch key { 7098 case "category": 7099 if value != nil { 7100 jtv, ok := value.(string) 7101 if !ok { 7102 return fmt.Errorf("expected ActionCategory to be of type string, got %T instead", value) 7103 } 7104 sv.Category = types.ActionCategory(jtv) 7105 } 7106 7107 case "owner": 7108 if value != nil { 7109 jtv, ok := value.(string) 7110 if !ok { 7111 return fmt.Errorf("expected ActionTypeOwner to be of type string, got %T instead", value) 7112 } 7113 sv.Owner = ptr.String(jtv) 7114 } 7115 7116 case "provider": 7117 if value != nil { 7118 jtv, ok := value.(string) 7119 if !ok { 7120 return fmt.Errorf("expected ActionProvider to be of type string, got %T instead", value) 7121 } 7122 sv.Provider = ptr.String(jtv) 7123 } 7124 7125 case "version": 7126 if value != nil { 7127 jtv, ok := value.(string) 7128 if !ok { 7129 return fmt.Errorf("expected Version to be of type string, got %T instead", value) 7130 } 7131 sv.Version = ptr.String(jtv) 7132 } 7133 7134 default: 7135 _, _ = key, value 7136 7137 } 7138 } 7139 *v = sv 7140 return nil 7141} 7142 7143func awsAwsjson11_deserializeDocumentActionTypeList(v *[]types.ActionType, value interface{}) error { 7144 if v == nil { 7145 return fmt.Errorf("unexpected nil of type %T", v) 7146 } 7147 if value == nil { 7148 return nil 7149 } 7150 7151 shape, ok := value.([]interface{}) 7152 if !ok { 7153 return fmt.Errorf("unexpected JSON type %v", value) 7154 } 7155 7156 var cv []types.ActionType 7157 if *v == nil { 7158 cv = []types.ActionType{} 7159 } else { 7160 cv = *v 7161 } 7162 7163 for _, value := range shape { 7164 var col types.ActionType 7165 destAddr := &col 7166 if err := awsAwsjson11_deserializeDocumentActionType(&destAddr, value); err != nil { 7167 return err 7168 } 7169 col = *destAddr 7170 cv = append(cv, col) 7171 7172 } 7173 *v = cv 7174 return nil 7175} 7176 7177func awsAwsjson11_deserializeDocumentActionTypeNotFoundException(v **types.ActionTypeNotFoundException, value interface{}) error { 7178 if v == nil { 7179 return fmt.Errorf("unexpected nil of type %T", v) 7180 } 7181 if value == nil { 7182 return nil 7183 } 7184 7185 shape, ok := value.(map[string]interface{}) 7186 if !ok { 7187 return fmt.Errorf("unexpected JSON type %v", value) 7188 } 7189 7190 var sv *types.ActionTypeNotFoundException 7191 if *v == nil { 7192 sv = &types.ActionTypeNotFoundException{} 7193 } else { 7194 sv = *v 7195 } 7196 7197 for key, value := range shape { 7198 switch key { 7199 case "message": 7200 if value != nil { 7201 jtv, ok := value.(string) 7202 if !ok { 7203 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7204 } 7205 sv.Message = ptr.String(jtv) 7206 } 7207 7208 default: 7209 _, _ = key, value 7210 7211 } 7212 } 7213 *v = sv 7214 return nil 7215} 7216 7217func awsAwsjson11_deserializeDocumentActionTypePermissions(v **types.ActionTypePermissions, value interface{}) error { 7218 if v == nil { 7219 return fmt.Errorf("unexpected nil of type %T", v) 7220 } 7221 if value == nil { 7222 return nil 7223 } 7224 7225 shape, ok := value.(map[string]interface{}) 7226 if !ok { 7227 return fmt.Errorf("unexpected JSON type %v", value) 7228 } 7229 7230 var sv *types.ActionTypePermissions 7231 if *v == nil { 7232 sv = &types.ActionTypePermissions{} 7233 } else { 7234 sv = *v 7235 } 7236 7237 for key, value := range shape { 7238 switch key { 7239 case "allowedAccounts": 7240 if err := awsAwsjson11_deserializeDocumentAllowedAccounts(&sv.AllowedAccounts, value); err != nil { 7241 return err 7242 } 7243 7244 default: 7245 _, _ = key, value 7246 7247 } 7248 } 7249 *v = sv 7250 return nil 7251} 7252 7253func awsAwsjson11_deserializeDocumentActionTypeProperties(v *[]types.ActionTypeProperty, value interface{}) error { 7254 if v == nil { 7255 return fmt.Errorf("unexpected nil of type %T", v) 7256 } 7257 if value == nil { 7258 return nil 7259 } 7260 7261 shape, ok := value.([]interface{}) 7262 if !ok { 7263 return fmt.Errorf("unexpected JSON type %v", value) 7264 } 7265 7266 var cv []types.ActionTypeProperty 7267 if *v == nil { 7268 cv = []types.ActionTypeProperty{} 7269 } else { 7270 cv = *v 7271 } 7272 7273 for _, value := range shape { 7274 var col types.ActionTypeProperty 7275 destAddr := &col 7276 if err := awsAwsjson11_deserializeDocumentActionTypeProperty(&destAddr, value); err != nil { 7277 return err 7278 } 7279 col = *destAddr 7280 cv = append(cv, col) 7281 7282 } 7283 *v = cv 7284 return nil 7285} 7286 7287func awsAwsjson11_deserializeDocumentActionTypeProperty(v **types.ActionTypeProperty, value interface{}) error { 7288 if v == nil { 7289 return fmt.Errorf("unexpected nil of type %T", v) 7290 } 7291 if value == nil { 7292 return nil 7293 } 7294 7295 shape, ok := value.(map[string]interface{}) 7296 if !ok { 7297 return fmt.Errorf("unexpected JSON type %v", value) 7298 } 7299 7300 var sv *types.ActionTypeProperty 7301 if *v == nil { 7302 sv = &types.ActionTypeProperty{} 7303 } else { 7304 sv = *v 7305 } 7306 7307 for key, value := range shape { 7308 switch key { 7309 case "description": 7310 if value != nil { 7311 jtv, ok := value.(string) 7312 if !ok { 7313 return fmt.Errorf("expected PropertyDescription to be of type string, got %T instead", value) 7314 } 7315 sv.Description = ptr.String(jtv) 7316 } 7317 7318 case "key": 7319 if value != nil { 7320 jtv, ok := value.(bool) 7321 if !ok { 7322 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 7323 } 7324 sv.Key = jtv 7325 } 7326 7327 case "name": 7328 if value != nil { 7329 jtv, ok := value.(string) 7330 if !ok { 7331 return fmt.Errorf("expected ActionConfigurationKey to be of type string, got %T instead", value) 7332 } 7333 sv.Name = ptr.String(jtv) 7334 } 7335 7336 case "noEcho": 7337 if value != nil { 7338 jtv, ok := value.(bool) 7339 if !ok { 7340 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 7341 } 7342 sv.NoEcho = jtv 7343 } 7344 7345 case "optional": 7346 if value != nil { 7347 jtv, ok := value.(bool) 7348 if !ok { 7349 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 7350 } 7351 sv.Optional = jtv 7352 } 7353 7354 case "queryable": 7355 if value != nil { 7356 jtv, ok := value.(bool) 7357 if !ok { 7358 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 7359 } 7360 sv.Queryable = jtv 7361 } 7362 7363 default: 7364 _, _ = key, value 7365 7366 } 7367 } 7368 *v = sv 7369 return nil 7370} 7371 7372func awsAwsjson11_deserializeDocumentActionTypeSettings(v **types.ActionTypeSettings, value interface{}) error { 7373 if v == nil { 7374 return fmt.Errorf("unexpected nil of type %T", v) 7375 } 7376 if value == nil { 7377 return nil 7378 } 7379 7380 shape, ok := value.(map[string]interface{}) 7381 if !ok { 7382 return fmt.Errorf("unexpected JSON type %v", value) 7383 } 7384 7385 var sv *types.ActionTypeSettings 7386 if *v == nil { 7387 sv = &types.ActionTypeSettings{} 7388 } else { 7389 sv = *v 7390 } 7391 7392 for key, value := range shape { 7393 switch key { 7394 case "entityUrlTemplate": 7395 if value != nil { 7396 jtv, ok := value.(string) 7397 if !ok { 7398 return fmt.Errorf("expected UrlTemplate to be of type string, got %T instead", value) 7399 } 7400 sv.EntityUrlTemplate = ptr.String(jtv) 7401 } 7402 7403 case "executionUrlTemplate": 7404 if value != nil { 7405 jtv, ok := value.(string) 7406 if !ok { 7407 return fmt.Errorf("expected UrlTemplate to be of type string, got %T instead", value) 7408 } 7409 sv.ExecutionUrlTemplate = ptr.String(jtv) 7410 } 7411 7412 case "revisionUrlTemplate": 7413 if value != nil { 7414 jtv, ok := value.(string) 7415 if !ok { 7416 return fmt.Errorf("expected UrlTemplate to be of type string, got %T instead", value) 7417 } 7418 sv.RevisionUrlTemplate = ptr.String(jtv) 7419 } 7420 7421 case "thirdPartyConfigurationUrl": 7422 if value != nil { 7423 jtv, ok := value.(string) 7424 if !ok { 7425 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 7426 } 7427 sv.ThirdPartyConfigurationUrl = ptr.String(jtv) 7428 } 7429 7430 default: 7431 _, _ = key, value 7432 7433 } 7434 } 7435 *v = sv 7436 return nil 7437} 7438 7439func awsAwsjson11_deserializeDocumentActionTypeUrls(v **types.ActionTypeUrls, value interface{}) error { 7440 if v == nil { 7441 return fmt.Errorf("unexpected nil of type %T", v) 7442 } 7443 if value == nil { 7444 return nil 7445 } 7446 7447 shape, ok := value.(map[string]interface{}) 7448 if !ok { 7449 return fmt.Errorf("unexpected JSON type %v", value) 7450 } 7451 7452 var sv *types.ActionTypeUrls 7453 if *v == nil { 7454 sv = &types.ActionTypeUrls{} 7455 } else { 7456 sv = *v 7457 } 7458 7459 for key, value := range shape { 7460 switch key { 7461 case "configurationUrl": 7462 if value != nil { 7463 jtv, ok := value.(string) 7464 if !ok { 7465 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 7466 } 7467 sv.ConfigurationUrl = ptr.String(jtv) 7468 } 7469 7470 case "entityUrlTemplate": 7471 if value != nil { 7472 jtv, ok := value.(string) 7473 if !ok { 7474 return fmt.Errorf("expected UrlTemplate to be of type string, got %T instead", value) 7475 } 7476 sv.EntityUrlTemplate = ptr.String(jtv) 7477 } 7478 7479 case "executionUrlTemplate": 7480 if value != nil { 7481 jtv, ok := value.(string) 7482 if !ok { 7483 return fmt.Errorf("expected UrlTemplate to be of type string, got %T instead", value) 7484 } 7485 sv.ExecutionUrlTemplate = ptr.String(jtv) 7486 } 7487 7488 case "revisionUrlTemplate": 7489 if value != nil { 7490 jtv, ok := value.(string) 7491 if !ok { 7492 return fmt.Errorf("expected UrlTemplate to be of type string, got %T instead", value) 7493 } 7494 sv.RevisionUrlTemplate = ptr.String(jtv) 7495 } 7496 7497 default: 7498 _, _ = key, value 7499 7500 } 7501 } 7502 *v = sv 7503 return nil 7504} 7505 7506func awsAwsjson11_deserializeDocumentAllowedAccounts(v *[]string, value interface{}) error { 7507 if v == nil { 7508 return fmt.Errorf("unexpected nil of type %T", v) 7509 } 7510 if value == nil { 7511 return nil 7512 } 7513 7514 shape, ok := value.([]interface{}) 7515 if !ok { 7516 return fmt.Errorf("unexpected JSON type %v", value) 7517 } 7518 7519 var cv []string 7520 if *v == nil { 7521 cv = []string{} 7522 } else { 7523 cv = *v 7524 } 7525 7526 for _, value := range shape { 7527 var col string 7528 if value != nil { 7529 jtv, ok := value.(string) 7530 if !ok { 7531 return fmt.Errorf("expected AllowedAccount to be of type string, got %T instead", value) 7532 } 7533 col = jtv 7534 } 7535 cv = append(cv, col) 7536 7537 } 7538 *v = cv 7539 return nil 7540} 7541 7542func awsAwsjson11_deserializeDocumentApprovalAlreadyCompletedException(v **types.ApprovalAlreadyCompletedException, value interface{}) error { 7543 if v == nil { 7544 return fmt.Errorf("unexpected nil of type %T", v) 7545 } 7546 if value == nil { 7547 return nil 7548 } 7549 7550 shape, ok := value.(map[string]interface{}) 7551 if !ok { 7552 return fmt.Errorf("unexpected JSON type %v", value) 7553 } 7554 7555 var sv *types.ApprovalAlreadyCompletedException 7556 if *v == nil { 7557 sv = &types.ApprovalAlreadyCompletedException{} 7558 } else { 7559 sv = *v 7560 } 7561 7562 for key, value := range shape { 7563 switch key { 7564 case "message": 7565 if value != nil { 7566 jtv, ok := value.(string) 7567 if !ok { 7568 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7569 } 7570 sv.Message = ptr.String(jtv) 7571 } 7572 7573 default: 7574 _, _ = key, value 7575 7576 } 7577 } 7578 *v = sv 7579 return nil 7580} 7581 7582func awsAwsjson11_deserializeDocumentArtifact(v **types.Artifact, value interface{}) error { 7583 if v == nil { 7584 return fmt.Errorf("unexpected nil of type %T", v) 7585 } 7586 if value == nil { 7587 return nil 7588 } 7589 7590 shape, ok := value.(map[string]interface{}) 7591 if !ok { 7592 return fmt.Errorf("unexpected JSON type %v", value) 7593 } 7594 7595 var sv *types.Artifact 7596 if *v == nil { 7597 sv = &types.Artifact{} 7598 } else { 7599 sv = *v 7600 } 7601 7602 for key, value := range shape { 7603 switch key { 7604 case "location": 7605 if err := awsAwsjson11_deserializeDocumentArtifactLocation(&sv.Location, value); err != nil { 7606 return err 7607 } 7608 7609 case "name": 7610 if value != nil { 7611 jtv, ok := value.(string) 7612 if !ok { 7613 return fmt.Errorf("expected ArtifactName to be of type string, got %T instead", value) 7614 } 7615 sv.Name = ptr.String(jtv) 7616 } 7617 7618 case "revision": 7619 if value != nil { 7620 jtv, ok := value.(string) 7621 if !ok { 7622 return fmt.Errorf("expected Revision to be of type string, got %T instead", value) 7623 } 7624 sv.Revision = ptr.String(jtv) 7625 } 7626 7627 default: 7628 _, _ = key, value 7629 7630 } 7631 } 7632 *v = sv 7633 return nil 7634} 7635 7636func awsAwsjson11_deserializeDocumentArtifactDetail(v **types.ArtifactDetail, value interface{}) error { 7637 if v == nil { 7638 return fmt.Errorf("unexpected nil of type %T", v) 7639 } 7640 if value == nil { 7641 return nil 7642 } 7643 7644 shape, ok := value.(map[string]interface{}) 7645 if !ok { 7646 return fmt.Errorf("unexpected JSON type %v", value) 7647 } 7648 7649 var sv *types.ArtifactDetail 7650 if *v == nil { 7651 sv = &types.ArtifactDetail{} 7652 } else { 7653 sv = *v 7654 } 7655 7656 for key, value := range shape { 7657 switch key { 7658 case "name": 7659 if value != nil { 7660 jtv, ok := value.(string) 7661 if !ok { 7662 return fmt.Errorf("expected ArtifactName to be of type string, got %T instead", value) 7663 } 7664 sv.Name = ptr.String(jtv) 7665 } 7666 7667 case "s3location": 7668 if err := awsAwsjson11_deserializeDocumentS3Location(&sv.S3location, value); err != nil { 7669 return err 7670 } 7671 7672 default: 7673 _, _ = key, value 7674 7675 } 7676 } 7677 *v = sv 7678 return nil 7679} 7680 7681func awsAwsjson11_deserializeDocumentArtifactDetailList(v *[]types.ArtifactDetail, value interface{}) error { 7682 if v == nil { 7683 return fmt.Errorf("unexpected nil of type %T", v) 7684 } 7685 if value == nil { 7686 return nil 7687 } 7688 7689 shape, ok := value.([]interface{}) 7690 if !ok { 7691 return fmt.Errorf("unexpected JSON type %v", value) 7692 } 7693 7694 var cv []types.ArtifactDetail 7695 if *v == nil { 7696 cv = []types.ArtifactDetail{} 7697 } else { 7698 cv = *v 7699 } 7700 7701 for _, value := range shape { 7702 var col types.ArtifactDetail 7703 destAddr := &col 7704 if err := awsAwsjson11_deserializeDocumentArtifactDetail(&destAddr, value); err != nil { 7705 return err 7706 } 7707 col = *destAddr 7708 cv = append(cv, col) 7709 7710 } 7711 *v = cv 7712 return nil 7713} 7714 7715func awsAwsjson11_deserializeDocumentArtifactDetails(v **types.ArtifactDetails, value interface{}) error { 7716 if v == nil { 7717 return fmt.Errorf("unexpected nil of type %T", v) 7718 } 7719 if value == nil { 7720 return nil 7721 } 7722 7723 shape, ok := value.(map[string]interface{}) 7724 if !ok { 7725 return fmt.Errorf("unexpected JSON type %v", value) 7726 } 7727 7728 var sv *types.ArtifactDetails 7729 if *v == nil { 7730 sv = &types.ArtifactDetails{} 7731 } else { 7732 sv = *v 7733 } 7734 7735 for key, value := range shape { 7736 switch key { 7737 case "maximumCount": 7738 if value != nil { 7739 jtv, ok := value.(json.Number) 7740 if !ok { 7741 return fmt.Errorf("expected MaximumArtifactCount to be json.Number, got %T instead", value) 7742 } 7743 i64, err := jtv.Int64() 7744 if err != nil { 7745 return err 7746 } 7747 sv.MaximumCount = int32(i64) 7748 } 7749 7750 case "minimumCount": 7751 if value != nil { 7752 jtv, ok := value.(json.Number) 7753 if !ok { 7754 return fmt.Errorf("expected MinimumArtifactCount to be json.Number, got %T instead", value) 7755 } 7756 i64, err := jtv.Int64() 7757 if err != nil { 7758 return err 7759 } 7760 sv.MinimumCount = int32(i64) 7761 } 7762 7763 default: 7764 _, _ = key, value 7765 7766 } 7767 } 7768 *v = sv 7769 return nil 7770} 7771 7772func awsAwsjson11_deserializeDocumentArtifactList(v *[]types.Artifact, value interface{}) error { 7773 if v == nil { 7774 return fmt.Errorf("unexpected nil of type %T", v) 7775 } 7776 if value == nil { 7777 return nil 7778 } 7779 7780 shape, ok := value.([]interface{}) 7781 if !ok { 7782 return fmt.Errorf("unexpected JSON type %v", value) 7783 } 7784 7785 var cv []types.Artifact 7786 if *v == nil { 7787 cv = []types.Artifact{} 7788 } else { 7789 cv = *v 7790 } 7791 7792 for _, value := range shape { 7793 var col types.Artifact 7794 destAddr := &col 7795 if err := awsAwsjson11_deserializeDocumentArtifact(&destAddr, value); err != nil { 7796 return err 7797 } 7798 col = *destAddr 7799 cv = append(cv, col) 7800 7801 } 7802 *v = cv 7803 return nil 7804} 7805 7806func awsAwsjson11_deserializeDocumentArtifactLocation(v **types.ArtifactLocation, value interface{}) error { 7807 if v == nil { 7808 return fmt.Errorf("unexpected nil of type %T", v) 7809 } 7810 if value == nil { 7811 return nil 7812 } 7813 7814 shape, ok := value.(map[string]interface{}) 7815 if !ok { 7816 return fmt.Errorf("unexpected JSON type %v", value) 7817 } 7818 7819 var sv *types.ArtifactLocation 7820 if *v == nil { 7821 sv = &types.ArtifactLocation{} 7822 } else { 7823 sv = *v 7824 } 7825 7826 for key, value := range shape { 7827 switch key { 7828 case "s3Location": 7829 if err := awsAwsjson11_deserializeDocumentS3ArtifactLocation(&sv.S3Location, value); err != nil { 7830 return err 7831 } 7832 7833 case "type": 7834 if value != nil { 7835 jtv, ok := value.(string) 7836 if !ok { 7837 return fmt.Errorf("expected ArtifactLocationType to be of type string, got %T instead", value) 7838 } 7839 sv.Type = types.ArtifactLocationType(jtv) 7840 } 7841 7842 default: 7843 _, _ = key, value 7844 7845 } 7846 } 7847 *v = sv 7848 return nil 7849} 7850 7851func awsAwsjson11_deserializeDocumentArtifactRevision(v **types.ArtifactRevision, value interface{}) error { 7852 if v == nil { 7853 return fmt.Errorf("unexpected nil of type %T", v) 7854 } 7855 if value == nil { 7856 return nil 7857 } 7858 7859 shape, ok := value.(map[string]interface{}) 7860 if !ok { 7861 return fmt.Errorf("unexpected JSON type %v", value) 7862 } 7863 7864 var sv *types.ArtifactRevision 7865 if *v == nil { 7866 sv = &types.ArtifactRevision{} 7867 } else { 7868 sv = *v 7869 } 7870 7871 for key, value := range shape { 7872 switch key { 7873 case "created": 7874 if value != nil { 7875 switch jtv := value.(type) { 7876 case json.Number: 7877 f64, err := jtv.Float64() 7878 if err != nil { 7879 return err 7880 } 7881 sv.Created = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7882 7883 default: 7884 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 7885 7886 } 7887 } 7888 7889 case "name": 7890 if value != nil { 7891 jtv, ok := value.(string) 7892 if !ok { 7893 return fmt.Errorf("expected ArtifactName to be of type string, got %T instead", value) 7894 } 7895 sv.Name = ptr.String(jtv) 7896 } 7897 7898 case "revisionChangeIdentifier": 7899 if value != nil { 7900 jtv, ok := value.(string) 7901 if !ok { 7902 return fmt.Errorf("expected RevisionChangeIdentifier to be of type string, got %T instead", value) 7903 } 7904 sv.RevisionChangeIdentifier = ptr.String(jtv) 7905 } 7906 7907 case "revisionId": 7908 if value != nil { 7909 jtv, ok := value.(string) 7910 if !ok { 7911 return fmt.Errorf("expected Revision to be of type string, got %T instead", value) 7912 } 7913 sv.RevisionId = ptr.String(jtv) 7914 } 7915 7916 case "revisionSummary": 7917 if value != nil { 7918 jtv, ok := value.(string) 7919 if !ok { 7920 return fmt.Errorf("expected RevisionSummary to be of type string, got %T instead", value) 7921 } 7922 sv.RevisionSummary = ptr.String(jtv) 7923 } 7924 7925 case "revisionUrl": 7926 if value != nil { 7927 jtv, ok := value.(string) 7928 if !ok { 7929 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 7930 } 7931 sv.RevisionUrl = ptr.String(jtv) 7932 } 7933 7934 default: 7935 _, _ = key, value 7936 7937 } 7938 } 7939 *v = sv 7940 return nil 7941} 7942 7943func awsAwsjson11_deserializeDocumentArtifactRevisionList(v *[]types.ArtifactRevision, value interface{}) error { 7944 if v == nil { 7945 return fmt.Errorf("unexpected nil of type %T", v) 7946 } 7947 if value == nil { 7948 return nil 7949 } 7950 7951 shape, ok := value.([]interface{}) 7952 if !ok { 7953 return fmt.Errorf("unexpected JSON type %v", value) 7954 } 7955 7956 var cv []types.ArtifactRevision 7957 if *v == nil { 7958 cv = []types.ArtifactRevision{} 7959 } else { 7960 cv = *v 7961 } 7962 7963 for _, value := range shape { 7964 var col types.ArtifactRevision 7965 destAddr := &col 7966 if err := awsAwsjson11_deserializeDocumentArtifactRevision(&destAddr, value); err != nil { 7967 return err 7968 } 7969 col = *destAddr 7970 cv = append(cv, col) 7971 7972 } 7973 *v = cv 7974 return nil 7975} 7976 7977func awsAwsjson11_deserializeDocumentArtifactStore(v **types.ArtifactStore, value interface{}) error { 7978 if v == nil { 7979 return fmt.Errorf("unexpected nil of type %T", v) 7980 } 7981 if value == nil { 7982 return nil 7983 } 7984 7985 shape, ok := value.(map[string]interface{}) 7986 if !ok { 7987 return fmt.Errorf("unexpected JSON type %v", value) 7988 } 7989 7990 var sv *types.ArtifactStore 7991 if *v == nil { 7992 sv = &types.ArtifactStore{} 7993 } else { 7994 sv = *v 7995 } 7996 7997 for key, value := range shape { 7998 switch key { 7999 case "encryptionKey": 8000 if err := awsAwsjson11_deserializeDocumentEncryptionKey(&sv.EncryptionKey, value); err != nil { 8001 return err 8002 } 8003 8004 case "location": 8005 if value != nil { 8006 jtv, ok := value.(string) 8007 if !ok { 8008 return fmt.Errorf("expected ArtifactStoreLocation to be of type string, got %T instead", value) 8009 } 8010 sv.Location = ptr.String(jtv) 8011 } 8012 8013 case "type": 8014 if value != nil { 8015 jtv, ok := value.(string) 8016 if !ok { 8017 return fmt.Errorf("expected ArtifactStoreType to be of type string, got %T instead", value) 8018 } 8019 sv.Type = types.ArtifactStoreType(jtv) 8020 } 8021 8022 default: 8023 _, _ = key, value 8024 8025 } 8026 } 8027 *v = sv 8028 return nil 8029} 8030 8031func awsAwsjson11_deserializeDocumentArtifactStoreMap(v *map[string]types.ArtifactStore, value interface{}) error { 8032 if v == nil { 8033 return fmt.Errorf("unexpected nil of type %T", v) 8034 } 8035 if value == nil { 8036 return nil 8037 } 8038 8039 shape, ok := value.(map[string]interface{}) 8040 if !ok { 8041 return fmt.Errorf("unexpected JSON type %v", value) 8042 } 8043 8044 var mv map[string]types.ArtifactStore 8045 if *v == nil { 8046 mv = map[string]types.ArtifactStore{} 8047 } else { 8048 mv = *v 8049 } 8050 8051 for key, value := range shape { 8052 var parsedVal types.ArtifactStore 8053 mapVar := parsedVal 8054 destAddr := &mapVar 8055 if err := awsAwsjson11_deserializeDocumentArtifactStore(&destAddr, value); err != nil { 8056 return err 8057 } 8058 parsedVal = *destAddr 8059 mv[key] = parsedVal 8060 8061 } 8062 *v = mv 8063 return nil 8064} 8065 8066func awsAwsjson11_deserializeDocumentAWSSessionCredentials(v **types.AWSSessionCredentials, value interface{}) error { 8067 if v == nil { 8068 return fmt.Errorf("unexpected nil of type %T", v) 8069 } 8070 if value == nil { 8071 return nil 8072 } 8073 8074 shape, ok := value.(map[string]interface{}) 8075 if !ok { 8076 return fmt.Errorf("unexpected JSON type %v", value) 8077 } 8078 8079 var sv *types.AWSSessionCredentials 8080 if *v == nil { 8081 sv = &types.AWSSessionCredentials{} 8082 } else { 8083 sv = *v 8084 } 8085 8086 for key, value := range shape { 8087 switch key { 8088 case "accessKeyId": 8089 if value != nil { 8090 jtv, ok := value.(string) 8091 if !ok { 8092 return fmt.Errorf("expected AccessKeyId to be of type string, got %T instead", value) 8093 } 8094 sv.AccessKeyId = ptr.String(jtv) 8095 } 8096 8097 case "secretAccessKey": 8098 if value != nil { 8099 jtv, ok := value.(string) 8100 if !ok { 8101 return fmt.Errorf("expected SecretAccessKey to be of type string, got %T instead", value) 8102 } 8103 sv.SecretAccessKey = ptr.String(jtv) 8104 } 8105 8106 case "sessionToken": 8107 if value != nil { 8108 jtv, ok := value.(string) 8109 if !ok { 8110 return fmt.Errorf("expected SessionToken to be of type string, got %T instead", value) 8111 } 8112 sv.SessionToken = ptr.String(jtv) 8113 } 8114 8115 default: 8116 _, _ = key, value 8117 8118 } 8119 } 8120 *v = sv 8121 return nil 8122} 8123 8124func awsAwsjson11_deserializeDocumentBlockerDeclaration(v **types.BlockerDeclaration, value interface{}) error { 8125 if v == nil { 8126 return fmt.Errorf("unexpected nil of type %T", v) 8127 } 8128 if value == nil { 8129 return nil 8130 } 8131 8132 shape, ok := value.(map[string]interface{}) 8133 if !ok { 8134 return fmt.Errorf("unexpected JSON type %v", value) 8135 } 8136 8137 var sv *types.BlockerDeclaration 8138 if *v == nil { 8139 sv = &types.BlockerDeclaration{} 8140 } else { 8141 sv = *v 8142 } 8143 8144 for key, value := range shape { 8145 switch key { 8146 case "name": 8147 if value != nil { 8148 jtv, ok := value.(string) 8149 if !ok { 8150 return fmt.Errorf("expected BlockerName to be of type string, got %T instead", value) 8151 } 8152 sv.Name = ptr.String(jtv) 8153 } 8154 8155 case "type": 8156 if value != nil { 8157 jtv, ok := value.(string) 8158 if !ok { 8159 return fmt.Errorf("expected BlockerType to be of type string, got %T instead", value) 8160 } 8161 sv.Type = types.BlockerType(jtv) 8162 } 8163 8164 default: 8165 _, _ = key, value 8166 8167 } 8168 } 8169 *v = sv 8170 return nil 8171} 8172 8173func awsAwsjson11_deserializeDocumentConcurrentModificationException(v **types.ConcurrentModificationException, value interface{}) error { 8174 if v == nil { 8175 return fmt.Errorf("unexpected nil of type %T", v) 8176 } 8177 if value == nil { 8178 return nil 8179 } 8180 8181 shape, ok := value.(map[string]interface{}) 8182 if !ok { 8183 return fmt.Errorf("unexpected JSON type %v", value) 8184 } 8185 8186 var sv *types.ConcurrentModificationException 8187 if *v == nil { 8188 sv = &types.ConcurrentModificationException{} 8189 } else { 8190 sv = *v 8191 } 8192 8193 for key, value := range shape { 8194 switch key { 8195 case "message": 8196 if value != nil { 8197 jtv, ok := value.(string) 8198 if !ok { 8199 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8200 } 8201 sv.Message = ptr.String(jtv) 8202 } 8203 8204 default: 8205 _, _ = key, value 8206 8207 } 8208 } 8209 *v = sv 8210 return nil 8211} 8212 8213func awsAwsjson11_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { 8214 if v == nil { 8215 return fmt.Errorf("unexpected nil of type %T", v) 8216 } 8217 if value == nil { 8218 return nil 8219 } 8220 8221 shape, ok := value.(map[string]interface{}) 8222 if !ok { 8223 return fmt.Errorf("unexpected JSON type %v", value) 8224 } 8225 8226 var sv *types.ConflictException 8227 if *v == nil { 8228 sv = &types.ConflictException{} 8229 } else { 8230 sv = *v 8231 } 8232 8233 for key, value := range shape { 8234 switch key { 8235 case "message": 8236 if value != nil { 8237 jtv, ok := value.(string) 8238 if !ok { 8239 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8240 } 8241 sv.Message = ptr.String(jtv) 8242 } 8243 8244 default: 8245 _, _ = key, value 8246 8247 } 8248 } 8249 *v = sv 8250 return nil 8251} 8252 8253func awsAwsjson11_deserializeDocumentDuplicatedStopRequestException(v **types.DuplicatedStopRequestException, value interface{}) error { 8254 if v == nil { 8255 return fmt.Errorf("unexpected nil of type %T", v) 8256 } 8257 if value == nil { 8258 return nil 8259 } 8260 8261 shape, ok := value.(map[string]interface{}) 8262 if !ok { 8263 return fmt.Errorf("unexpected JSON type %v", value) 8264 } 8265 8266 var sv *types.DuplicatedStopRequestException 8267 if *v == nil { 8268 sv = &types.DuplicatedStopRequestException{} 8269 } else { 8270 sv = *v 8271 } 8272 8273 for key, value := range shape { 8274 switch key { 8275 case "message": 8276 if value != nil { 8277 jtv, ok := value.(string) 8278 if !ok { 8279 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8280 } 8281 sv.Message = ptr.String(jtv) 8282 } 8283 8284 default: 8285 _, _ = key, value 8286 8287 } 8288 } 8289 *v = sv 8290 return nil 8291} 8292 8293func awsAwsjson11_deserializeDocumentEncryptionKey(v **types.EncryptionKey, value interface{}) error { 8294 if v == nil { 8295 return fmt.Errorf("unexpected nil of type %T", v) 8296 } 8297 if value == nil { 8298 return nil 8299 } 8300 8301 shape, ok := value.(map[string]interface{}) 8302 if !ok { 8303 return fmt.Errorf("unexpected JSON type %v", value) 8304 } 8305 8306 var sv *types.EncryptionKey 8307 if *v == nil { 8308 sv = &types.EncryptionKey{} 8309 } else { 8310 sv = *v 8311 } 8312 8313 for key, value := range shape { 8314 switch key { 8315 case "id": 8316 if value != nil { 8317 jtv, ok := value.(string) 8318 if !ok { 8319 return fmt.Errorf("expected EncryptionKeyId to be of type string, got %T instead", value) 8320 } 8321 sv.Id = ptr.String(jtv) 8322 } 8323 8324 case "type": 8325 if value != nil { 8326 jtv, ok := value.(string) 8327 if !ok { 8328 return fmt.Errorf("expected EncryptionKeyType to be of type string, got %T instead", value) 8329 } 8330 sv.Type = types.EncryptionKeyType(jtv) 8331 } 8332 8333 default: 8334 _, _ = key, value 8335 8336 } 8337 } 8338 *v = sv 8339 return nil 8340} 8341 8342func awsAwsjson11_deserializeDocumentErrorDetails(v **types.ErrorDetails, value interface{}) error { 8343 if v == nil { 8344 return fmt.Errorf("unexpected nil of type %T", v) 8345 } 8346 if value == nil { 8347 return nil 8348 } 8349 8350 shape, ok := value.(map[string]interface{}) 8351 if !ok { 8352 return fmt.Errorf("unexpected JSON type %v", value) 8353 } 8354 8355 var sv *types.ErrorDetails 8356 if *v == nil { 8357 sv = &types.ErrorDetails{} 8358 } else { 8359 sv = *v 8360 } 8361 8362 for key, value := range shape { 8363 switch key { 8364 case "code": 8365 if value != nil { 8366 jtv, ok := value.(string) 8367 if !ok { 8368 return fmt.Errorf("expected Code to be of type string, got %T instead", value) 8369 } 8370 sv.Code = ptr.String(jtv) 8371 } 8372 8373 case "message": 8374 if value != nil { 8375 jtv, ok := value.(string) 8376 if !ok { 8377 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8378 } 8379 sv.Message = ptr.String(jtv) 8380 } 8381 8382 default: 8383 _, _ = key, value 8384 8385 } 8386 } 8387 *v = sv 8388 return nil 8389} 8390 8391func awsAwsjson11_deserializeDocumentExecutionTrigger(v **types.ExecutionTrigger, value interface{}) error { 8392 if v == nil { 8393 return fmt.Errorf("unexpected nil of type %T", v) 8394 } 8395 if value == nil { 8396 return nil 8397 } 8398 8399 shape, ok := value.(map[string]interface{}) 8400 if !ok { 8401 return fmt.Errorf("unexpected JSON type %v", value) 8402 } 8403 8404 var sv *types.ExecutionTrigger 8405 if *v == nil { 8406 sv = &types.ExecutionTrigger{} 8407 } else { 8408 sv = *v 8409 } 8410 8411 for key, value := range shape { 8412 switch key { 8413 case "triggerDetail": 8414 if value != nil { 8415 jtv, ok := value.(string) 8416 if !ok { 8417 return fmt.Errorf("expected TriggerDetail to be of type string, got %T instead", value) 8418 } 8419 sv.TriggerDetail = ptr.String(jtv) 8420 } 8421 8422 case "triggerType": 8423 if value != nil { 8424 jtv, ok := value.(string) 8425 if !ok { 8426 return fmt.Errorf("expected TriggerType to be of type string, got %T instead", value) 8427 } 8428 sv.TriggerType = types.TriggerType(jtv) 8429 } 8430 8431 default: 8432 _, _ = key, value 8433 8434 } 8435 } 8436 *v = sv 8437 return nil 8438} 8439 8440func awsAwsjson11_deserializeDocumentExecutorConfiguration(v **types.ExecutorConfiguration, value interface{}) error { 8441 if v == nil { 8442 return fmt.Errorf("unexpected nil of type %T", v) 8443 } 8444 if value == nil { 8445 return nil 8446 } 8447 8448 shape, ok := value.(map[string]interface{}) 8449 if !ok { 8450 return fmt.Errorf("unexpected JSON type %v", value) 8451 } 8452 8453 var sv *types.ExecutorConfiguration 8454 if *v == nil { 8455 sv = &types.ExecutorConfiguration{} 8456 } else { 8457 sv = *v 8458 } 8459 8460 for key, value := range shape { 8461 switch key { 8462 case "jobWorkerExecutorConfiguration": 8463 if err := awsAwsjson11_deserializeDocumentJobWorkerExecutorConfiguration(&sv.JobWorkerExecutorConfiguration, value); err != nil { 8464 return err 8465 } 8466 8467 case "lambdaExecutorConfiguration": 8468 if err := awsAwsjson11_deserializeDocumentLambdaExecutorConfiguration(&sv.LambdaExecutorConfiguration, value); err != nil { 8469 return err 8470 } 8471 8472 default: 8473 _, _ = key, value 8474 8475 } 8476 } 8477 *v = sv 8478 return nil 8479} 8480 8481func awsAwsjson11_deserializeDocumentInputArtifact(v **types.InputArtifact, value interface{}) error { 8482 if v == nil { 8483 return fmt.Errorf("unexpected nil of type %T", v) 8484 } 8485 if value == nil { 8486 return nil 8487 } 8488 8489 shape, ok := value.(map[string]interface{}) 8490 if !ok { 8491 return fmt.Errorf("unexpected JSON type %v", value) 8492 } 8493 8494 var sv *types.InputArtifact 8495 if *v == nil { 8496 sv = &types.InputArtifact{} 8497 } else { 8498 sv = *v 8499 } 8500 8501 for key, value := range shape { 8502 switch key { 8503 case "name": 8504 if value != nil { 8505 jtv, ok := value.(string) 8506 if !ok { 8507 return fmt.Errorf("expected ArtifactName to be of type string, got %T instead", value) 8508 } 8509 sv.Name = ptr.String(jtv) 8510 } 8511 8512 default: 8513 _, _ = key, value 8514 8515 } 8516 } 8517 *v = sv 8518 return nil 8519} 8520 8521func awsAwsjson11_deserializeDocumentInputArtifactList(v *[]types.InputArtifact, value interface{}) error { 8522 if v == nil { 8523 return fmt.Errorf("unexpected nil of type %T", v) 8524 } 8525 if value == nil { 8526 return nil 8527 } 8528 8529 shape, ok := value.([]interface{}) 8530 if !ok { 8531 return fmt.Errorf("unexpected JSON type %v", value) 8532 } 8533 8534 var cv []types.InputArtifact 8535 if *v == nil { 8536 cv = []types.InputArtifact{} 8537 } else { 8538 cv = *v 8539 } 8540 8541 for _, value := range shape { 8542 var col types.InputArtifact 8543 destAddr := &col 8544 if err := awsAwsjson11_deserializeDocumentInputArtifact(&destAddr, value); err != nil { 8545 return err 8546 } 8547 col = *destAddr 8548 cv = append(cv, col) 8549 8550 } 8551 *v = cv 8552 return nil 8553} 8554 8555func awsAwsjson11_deserializeDocumentInvalidActionDeclarationException(v **types.InvalidActionDeclarationException, value interface{}) error { 8556 if v == nil { 8557 return fmt.Errorf("unexpected nil of type %T", v) 8558 } 8559 if value == nil { 8560 return nil 8561 } 8562 8563 shape, ok := value.(map[string]interface{}) 8564 if !ok { 8565 return fmt.Errorf("unexpected JSON type %v", value) 8566 } 8567 8568 var sv *types.InvalidActionDeclarationException 8569 if *v == nil { 8570 sv = &types.InvalidActionDeclarationException{} 8571 } else { 8572 sv = *v 8573 } 8574 8575 for key, value := range shape { 8576 switch key { 8577 case "message": 8578 if value != nil { 8579 jtv, ok := value.(string) 8580 if !ok { 8581 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8582 } 8583 sv.Message = ptr.String(jtv) 8584 } 8585 8586 default: 8587 _, _ = key, value 8588 8589 } 8590 } 8591 *v = sv 8592 return nil 8593} 8594 8595func awsAwsjson11_deserializeDocumentInvalidApprovalTokenException(v **types.InvalidApprovalTokenException, value interface{}) error { 8596 if v == nil { 8597 return fmt.Errorf("unexpected nil of type %T", v) 8598 } 8599 if value == nil { 8600 return nil 8601 } 8602 8603 shape, ok := value.(map[string]interface{}) 8604 if !ok { 8605 return fmt.Errorf("unexpected JSON type %v", value) 8606 } 8607 8608 var sv *types.InvalidApprovalTokenException 8609 if *v == nil { 8610 sv = &types.InvalidApprovalTokenException{} 8611 } else { 8612 sv = *v 8613 } 8614 8615 for key, value := range shape { 8616 switch key { 8617 case "message": 8618 if value != nil { 8619 jtv, ok := value.(string) 8620 if !ok { 8621 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8622 } 8623 sv.Message = ptr.String(jtv) 8624 } 8625 8626 default: 8627 _, _ = key, value 8628 8629 } 8630 } 8631 *v = sv 8632 return nil 8633} 8634 8635func awsAwsjson11_deserializeDocumentInvalidArnException(v **types.InvalidArnException, value interface{}) error { 8636 if v == nil { 8637 return fmt.Errorf("unexpected nil of type %T", v) 8638 } 8639 if value == nil { 8640 return nil 8641 } 8642 8643 shape, ok := value.(map[string]interface{}) 8644 if !ok { 8645 return fmt.Errorf("unexpected JSON type %v", value) 8646 } 8647 8648 var sv *types.InvalidArnException 8649 if *v == nil { 8650 sv = &types.InvalidArnException{} 8651 } else { 8652 sv = *v 8653 } 8654 8655 for key, value := range shape { 8656 switch key { 8657 case "message": 8658 if value != nil { 8659 jtv, ok := value.(string) 8660 if !ok { 8661 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8662 } 8663 sv.Message = ptr.String(jtv) 8664 } 8665 8666 default: 8667 _, _ = key, value 8668 8669 } 8670 } 8671 *v = sv 8672 return nil 8673} 8674 8675func awsAwsjson11_deserializeDocumentInvalidBlockerDeclarationException(v **types.InvalidBlockerDeclarationException, value interface{}) error { 8676 if v == nil { 8677 return fmt.Errorf("unexpected nil of type %T", v) 8678 } 8679 if value == nil { 8680 return nil 8681 } 8682 8683 shape, ok := value.(map[string]interface{}) 8684 if !ok { 8685 return fmt.Errorf("unexpected JSON type %v", value) 8686 } 8687 8688 var sv *types.InvalidBlockerDeclarationException 8689 if *v == nil { 8690 sv = &types.InvalidBlockerDeclarationException{} 8691 } else { 8692 sv = *v 8693 } 8694 8695 for key, value := range shape { 8696 switch key { 8697 case "message": 8698 if value != nil { 8699 jtv, ok := value.(string) 8700 if !ok { 8701 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8702 } 8703 sv.Message = ptr.String(jtv) 8704 } 8705 8706 default: 8707 _, _ = key, value 8708 8709 } 8710 } 8711 *v = sv 8712 return nil 8713} 8714 8715func awsAwsjson11_deserializeDocumentInvalidClientTokenException(v **types.InvalidClientTokenException, value interface{}) error { 8716 if v == nil { 8717 return fmt.Errorf("unexpected nil of type %T", v) 8718 } 8719 if value == nil { 8720 return nil 8721 } 8722 8723 shape, ok := value.(map[string]interface{}) 8724 if !ok { 8725 return fmt.Errorf("unexpected JSON type %v", value) 8726 } 8727 8728 var sv *types.InvalidClientTokenException 8729 if *v == nil { 8730 sv = &types.InvalidClientTokenException{} 8731 } else { 8732 sv = *v 8733 } 8734 8735 for key, value := range shape { 8736 switch key { 8737 case "message": 8738 if value != nil { 8739 jtv, ok := value.(string) 8740 if !ok { 8741 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8742 } 8743 sv.Message = ptr.String(jtv) 8744 } 8745 8746 default: 8747 _, _ = key, value 8748 8749 } 8750 } 8751 *v = sv 8752 return nil 8753} 8754 8755func awsAwsjson11_deserializeDocumentInvalidJobException(v **types.InvalidJobException, value interface{}) error { 8756 if v == nil { 8757 return fmt.Errorf("unexpected nil of type %T", v) 8758 } 8759 if value == nil { 8760 return nil 8761 } 8762 8763 shape, ok := value.(map[string]interface{}) 8764 if !ok { 8765 return fmt.Errorf("unexpected JSON type %v", value) 8766 } 8767 8768 var sv *types.InvalidJobException 8769 if *v == nil { 8770 sv = &types.InvalidJobException{} 8771 } else { 8772 sv = *v 8773 } 8774 8775 for key, value := range shape { 8776 switch key { 8777 case "message": 8778 if value != nil { 8779 jtv, ok := value.(string) 8780 if !ok { 8781 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8782 } 8783 sv.Message = ptr.String(jtv) 8784 } 8785 8786 default: 8787 _, _ = key, value 8788 8789 } 8790 } 8791 *v = sv 8792 return nil 8793} 8794 8795func awsAwsjson11_deserializeDocumentInvalidJobStateException(v **types.InvalidJobStateException, value interface{}) error { 8796 if v == nil { 8797 return fmt.Errorf("unexpected nil of type %T", v) 8798 } 8799 if value == nil { 8800 return nil 8801 } 8802 8803 shape, ok := value.(map[string]interface{}) 8804 if !ok { 8805 return fmt.Errorf("unexpected JSON type %v", value) 8806 } 8807 8808 var sv *types.InvalidJobStateException 8809 if *v == nil { 8810 sv = &types.InvalidJobStateException{} 8811 } else { 8812 sv = *v 8813 } 8814 8815 for key, value := range shape { 8816 switch key { 8817 case "message": 8818 if value != nil { 8819 jtv, ok := value.(string) 8820 if !ok { 8821 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8822 } 8823 sv.Message = ptr.String(jtv) 8824 } 8825 8826 default: 8827 _, _ = key, value 8828 8829 } 8830 } 8831 *v = sv 8832 return nil 8833} 8834 8835func awsAwsjson11_deserializeDocumentInvalidNextTokenException(v **types.InvalidNextTokenException, value interface{}) error { 8836 if v == nil { 8837 return fmt.Errorf("unexpected nil of type %T", v) 8838 } 8839 if value == nil { 8840 return nil 8841 } 8842 8843 shape, ok := value.(map[string]interface{}) 8844 if !ok { 8845 return fmt.Errorf("unexpected JSON type %v", value) 8846 } 8847 8848 var sv *types.InvalidNextTokenException 8849 if *v == nil { 8850 sv = &types.InvalidNextTokenException{} 8851 } else { 8852 sv = *v 8853 } 8854 8855 for key, value := range shape { 8856 switch key { 8857 case "message": 8858 if value != nil { 8859 jtv, ok := value.(string) 8860 if !ok { 8861 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8862 } 8863 sv.Message = ptr.String(jtv) 8864 } 8865 8866 default: 8867 _, _ = key, value 8868 8869 } 8870 } 8871 *v = sv 8872 return nil 8873} 8874 8875func awsAwsjson11_deserializeDocumentInvalidNonceException(v **types.InvalidNonceException, value interface{}) error { 8876 if v == nil { 8877 return fmt.Errorf("unexpected nil of type %T", v) 8878 } 8879 if value == nil { 8880 return nil 8881 } 8882 8883 shape, ok := value.(map[string]interface{}) 8884 if !ok { 8885 return fmt.Errorf("unexpected JSON type %v", value) 8886 } 8887 8888 var sv *types.InvalidNonceException 8889 if *v == nil { 8890 sv = &types.InvalidNonceException{} 8891 } else { 8892 sv = *v 8893 } 8894 8895 for key, value := range shape { 8896 switch key { 8897 case "message": 8898 if value != nil { 8899 jtv, ok := value.(string) 8900 if !ok { 8901 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8902 } 8903 sv.Message = ptr.String(jtv) 8904 } 8905 8906 default: 8907 _, _ = key, value 8908 8909 } 8910 } 8911 *v = sv 8912 return nil 8913} 8914 8915func awsAwsjson11_deserializeDocumentInvalidStageDeclarationException(v **types.InvalidStageDeclarationException, value interface{}) error { 8916 if v == nil { 8917 return fmt.Errorf("unexpected nil of type %T", v) 8918 } 8919 if value == nil { 8920 return nil 8921 } 8922 8923 shape, ok := value.(map[string]interface{}) 8924 if !ok { 8925 return fmt.Errorf("unexpected JSON type %v", value) 8926 } 8927 8928 var sv *types.InvalidStageDeclarationException 8929 if *v == nil { 8930 sv = &types.InvalidStageDeclarationException{} 8931 } else { 8932 sv = *v 8933 } 8934 8935 for key, value := range shape { 8936 switch key { 8937 case "message": 8938 if value != nil { 8939 jtv, ok := value.(string) 8940 if !ok { 8941 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8942 } 8943 sv.Message = ptr.String(jtv) 8944 } 8945 8946 default: 8947 _, _ = key, value 8948 8949 } 8950 } 8951 *v = sv 8952 return nil 8953} 8954 8955func awsAwsjson11_deserializeDocumentInvalidStructureException(v **types.InvalidStructureException, value interface{}) error { 8956 if v == nil { 8957 return fmt.Errorf("unexpected nil of type %T", v) 8958 } 8959 if value == nil { 8960 return nil 8961 } 8962 8963 shape, ok := value.(map[string]interface{}) 8964 if !ok { 8965 return fmt.Errorf("unexpected JSON type %v", value) 8966 } 8967 8968 var sv *types.InvalidStructureException 8969 if *v == nil { 8970 sv = &types.InvalidStructureException{} 8971 } else { 8972 sv = *v 8973 } 8974 8975 for key, value := range shape { 8976 switch key { 8977 case "message": 8978 if value != nil { 8979 jtv, ok := value.(string) 8980 if !ok { 8981 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8982 } 8983 sv.Message = ptr.String(jtv) 8984 } 8985 8986 default: 8987 _, _ = key, value 8988 8989 } 8990 } 8991 *v = sv 8992 return nil 8993} 8994 8995func awsAwsjson11_deserializeDocumentInvalidTagsException(v **types.InvalidTagsException, value interface{}) error { 8996 if v == nil { 8997 return fmt.Errorf("unexpected nil of type %T", v) 8998 } 8999 if value == nil { 9000 return nil 9001 } 9002 9003 shape, ok := value.(map[string]interface{}) 9004 if !ok { 9005 return fmt.Errorf("unexpected JSON type %v", value) 9006 } 9007 9008 var sv *types.InvalidTagsException 9009 if *v == nil { 9010 sv = &types.InvalidTagsException{} 9011 } else { 9012 sv = *v 9013 } 9014 9015 for key, value := range shape { 9016 switch key { 9017 case "message": 9018 if value != nil { 9019 jtv, ok := value.(string) 9020 if !ok { 9021 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9022 } 9023 sv.Message = ptr.String(jtv) 9024 } 9025 9026 default: 9027 _, _ = key, value 9028 9029 } 9030 } 9031 *v = sv 9032 return nil 9033} 9034 9035func awsAwsjson11_deserializeDocumentInvalidWebhookAuthenticationParametersException(v **types.InvalidWebhookAuthenticationParametersException, value interface{}) error { 9036 if v == nil { 9037 return fmt.Errorf("unexpected nil of type %T", v) 9038 } 9039 if value == nil { 9040 return nil 9041 } 9042 9043 shape, ok := value.(map[string]interface{}) 9044 if !ok { 9045 return fmt.Errorf("unexpected JSON type %v", value) 9046 } 9047 9048 var sv *types.InvalidWebhookAuthenticationParametersException 9049 if *v == nil { 9050 sv = &types.InvalidWebhookAuthenticationParametersException{} 9051 } else { 9052 sv = *v 9053 } 9054 9055 for key, value := range shape { 9056 switch key { 9057 case "message": 9058 if value != nil { 9059 jtv, ok := value.(string) 9060 if !ok { 9061 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9062 } 9063 sv.Message = ptr.String(jtv) 9064 } 9065 9066 default: 9067 _, _ = key, value 9068 9069 } 9070 } 9071 *v = sv 9072 return nil 9073} 9074 9075func awsAwsjson11_deserializeDocumentInvalidWebhookFilterPatternException(v **types.InvalidWebhookFilterPatternException, value interface{}) error { 9076 if v == nil { 9077 return fmt.Errorf("unexpected nil of type %T", v) 9078 } 9079 if value == nil { 9080 return nil 9081 } 9082 9083 shape, ok := value.(map[string]interface{}) 9084 if !ok { 9085 return fmt.Errorf("unexpected JSON type %v", value) 9086 } 9087 9088 var sv *types.InvalidWebhookFilterPatternException 9089 if *v == nil { 9090 sv = &types.InvalidWebhookFilterPatternException{} 9091 } else { 9092 sv = *v 9093 } 9094 9095 for key, value := range shape { 9096 switch key { 9097 case "message": 9098 if value != nil { 9099 jtv, ok := value.(string) 9100 if !ok { 9101 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9102 } 9103 sv.Message = ptr.String(jtv) 9104 } 9105 9106 default: 9107 _, _ = key, value 9108 9109 } 9110 } 9111 *v = sv 9112 return nil 9113} 9114 9115func awsAwsjson11_deserializeDocumentJob(v **types.Job, value interface{}) error { 9116 if v == nil { 9117 return fmt.Errorf("unexpected nil of type %T", v) 9118 } 9119 if value == nil { 9120 return nil 9121 } 9122 9123 shape, ok := value.(map[string]interface{}) 9124 if !ok { 9125 return fmt.Errorf("unexpected JSON type %v", value) 9126 } 9127 9128 var sv *types.Job 9129 if *v == nil { 9130 sv = &types.Job{} 9131 } else { 9132 sv = *v 9133 } 9134 9135 for key, value := range shape { 9136 switch key { 9137 case "accountId": 9138 if value != nil { 9139 jtv, ok := value.(string) 9140 if !ok { 9141 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 9142 } 9143 sv.AccountId = ptr.String(jtv) 9144 } 9145 9146 case "data": 9147 if err := awsAwsjson11_deserializeDocumentJobData(&sv.Data, value); err != nil { 9148 return err 9149 } 9150 9151 case "id": 9152 if value != nil { 9153 jtv, ok := value.(string) 9154 if !ok { 9155 return fmt.Errorf("expected JobId to be of type string, got %T instead", value) 9156 } 9157 sv.Id = ptr.String(jtv) 9158 } 9159 9160 case "nonce": 9161 if value != nil { 9162 jtv, ok := value.(string) 9163 if !ok { 9164 return fmt.Errorf("expected Nonce to be of type string, got %T instead", value) 9165 } 9166 sv.Nonce = ptr.String(jtv) 9167 } 9168 9169 default: 9170 _, _ = key, value 9171 9172 } 9173 } 9174 *v = sv 9175 return nil 9176} 9177 9178func awsAwsjson11_deserializeDocumentJobData(v **types.JobData, value interface{}) error { 9179 if v == nil { 9180 return fmt.Errorf("unexpected nil of type %T", v) 9181 } 9182 if value == nil { 9183 return nil 9184 } 9185 9186 shape, ok := value.(map[string]interface{}) 9187 if !ok { 9188 return fmt.Errorf("unexpected JSON type %v", value) 9189 } 9190 9191 var sv *types.JobData 9192 if *v == nil { 9193 sv = &types.JobData{} 9194 } else { 9195 sv = *v 9196 } 9197 9198 for key, value := range shape { 9199 switch key { 9200 case "actionConfiguration": 9201 if err := awsAwsjson11_deserializeDocumentActionConfiguration(&sv.ActionConfiguration, value); err != nil { 9202 return err 9203 } 9204 9205 case "actionTypeId": 9206 if err := awsAwsjson11_deserializeDocumentActionTypeId(&sv.ActionTypeId, value); err != nil { 9207 return err 9208 } 9209 9210 case "artifactCredentials": 9211 if err := awsAwsjson11_deserializeDocumentAWSSessionCredentials(&sv.ArtifactCredentials, value); err != nil { 9212 return err 9213 } 9214 9215 case "continuationToken": 9216 if value != nil { 9217 jtv, ok := value.(string) 9218 if !ok { 9219 return fmt.Errorf("expected ContinuationToken to be of type string, got %T instead", value) 9220 } 9221 sv.ContinuationToken = ptr.String(jtv) 9222 } 9223 9224 case "encryptionKey": 9225 if err := awsAwsjson11_deserializeDocumentEncryptionKey(&sv.EncryptionKey, value); err != nil { 9226 return err 9227 } 9228 9229 case "inputArtifacts": 9230 if err := awsAwsjson11_deserializeDocumentArtifactList(&sv.InputArtifacts, value); err != nil { 9231 return err 9232 } 9233 9234 case "outputArtifacts": 9235 if err := awsAwsjson11_deserializeDocumentArtifactList(&sv.OutputArtifacts, value); err != nil { 9236 return err 9237 } 9238 9239 case "pipelineContext": 9240 if err := awsAwsjson11_deserializeDocumentPipelineContext(&sv.PipelineContext, value); err != nil { 9241 return err 9242 } 9243 9244 default: 9245 _, _ = key, value 9246 9247 } 9248 } 9249 *v = sv 9250 return nil 9251} 9252 9253func awsAwsjson11_deserializeDocumentJobDetails(v **types.JobDetails, value interface{}) error { 9254 if v == nil { 9255 return fmt.Errorf("unexpected nil of type %T", v) 9256 } 9257 if value == nil { 9258 return nil 9259 } 9260 9261 shape, ok := value.(map[string]interface{}) 9262 if !ok { 9263 return fmt.Errorf("unexpected JSON type %v", value) 9264 } 9265 9266 var sv *types.JobDetails 9267 if *v == nil { 9268 sv = &types.JobDetails{} 9269 } else { 9270 sv = *v 9271 } 9272 9273 for key, value := range shape { 9274 switch key { 9275 case "accountId": 9276 if value != nil { 9277 jtv, ok := value.(string) 9278 if !ok { 9279 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 9280 } 9281 sv.AccountId = ptr.String(jtv) 9282 } 9283 9284 case "data": 9285 if err := awsAwsjson11_deserializeDocumentJobData(&sv.Data, value); err != nil { 9286 return err 9287 } 9288 9289 case "id": 9290 if value != nil { 9291 jtv, ok := value.(string) 9292 if !ok { 9293 return fmt.Errorf("expected JobId to be of type string, got %T instead", value) 9294 } 9295 sv.Id = ptr.String(jtv) 9296 } 9297 9298 default: 9299 _, _ = key, value 9300 9301 } 9302 } 9303 *v = sv 9304 return nil 9305} 9306 9307func awsAwsjson11_deserializeDocumentJobList(v *[]types.Job, value interface{}) error { 9308 if v == nil { 9309 return fmt.Errorf("unexpected nil of type %T", v) 9310 } 9311 if value == nil { 9312 return nil 9313 } 9314 9315 shape, ok := value.([]interface{}) 9316 if !ok { 9317 return fmt.Errorf("unexpected JSON type %v", value) 9318 } 9319 9320 var cv []types.Job 9321 if *v == nil { 9322 cv = []types.Job{} 9323 } else { 9324 cv = *v 9325 } 9326 9327 for _, value := range shape { 9328 var col types.Job 9329 destAddr := &col 9330 if err := awsAwsjson11_deserializeDocumentJob(&destAddr, value); err != nil { 9331 return err 9332 } 9333 col = *destAddr 9334 cv = append(cv, col) 9335 9336 } 9337 *v = cv 9338 return nil 9339} 9340 9341func awsAwsjson11_deserializeDocumentJobNotFoundException(v **types.JobNotFoundException, value interface{}) error { 9342 if v == nil { 9343 return fmt.Errorf("unexpected nil of type %T", v) 9344 } 9345 if value == nil { 9346 return nil 9347 } 9348 9349 shape, ok := value.(map[string]interface{}) 9350 if !ok { 9351 return fmt.Errorf("unexpected JSON type %v", value) 9352 } 9353 9354 var sv *types.JobNotFoundException 9355 if *v == nil { 9356 sv = &types.JobNotFoundException{} 9357 } else { 9358 sv = *v 9359 } 9360 9361 for key, value := range shape { 9362 switch key { 9363 case "message": 9364 if value != nil { 9365 jtv, ok := value.(string) 9366 if !ok { 9367 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9368 } 9369 sv.Message = ptr.String(jtv) 9370 } 9371 9372 default: 9373 _, _ = key, value 9374 9375 } 9376 } 9377 *v = sv 9378 return nil 9379} 9380 9381func awsAwsjson11_deserializeDocumentJobWorkerExecutorConfiguration(v **types.JobWorkerExecutorConfiguration, value interface{}) error { 9382 if v == nil { 9383 return fmt.Errorf("unexpected nil of type %T", v) 9384 } 9385 if value == nil { 9386 return nil 9387 } 9388 9389 shape, ok := value.(map[string]interface{}) 9390 if !ok { 9391 return fmt.Errorf("unexpected JSON type %v", value) 9392 } 9393 9394 var sv *types.JobWorkerExecutorConfiguration 9395 if *v == nil { 9396 sv = &types.JobWorkerExecutorConfiguration{} 9397 } else { 9398 sv = *v 9399 } 9400 9401 for key, value := range shape { 9402 switch key { 9403 case "pollingAccounts": 9404 if err := awsAwsjson11_deserializeDocumentPollingAccountList(&sv.PollingAccounts, value); err != nil { 9405 return err 9406 } 9407 9408 case "pollingServicePrincipals": 9409 if err := awsAwsjson11_deserializeDocumentPollingServicePrincipalList(&sv.PollingServicePrincipals, value); err != nil { 9410 return err 9411 } 9412 9413 default: 9414 _, _ = key, value 9415 9416 } 9417 } 9418 *v = sv 9419 return nil 9420} 9421 9422func awsAwsjson11_deserializeDocumentLambdaExecutorConfiguration(v **types.LambdaExecutorConfiguration, value interface{}) error { 9423 if v == nil { 9424 return fmt.Errorf("unexpected nil of type %T", v) 9425 } 9426 if value == nil { 9427 return nil 9428 } 9429 9430 shape, ok := value.(map[string]interface{}) 9431 if !ok { 9432 return fmt.Errorf("unexpected JSON type %v", value) 9433 } 9434 9435 var sv *types.LambdaExecutorConfiguration 9436 if *v == nil { 9437 sv = &types.LambdaExecutorConfiguration{} 9438 } else { 9439 sv = *v 9440 } 9441 9442 for key, value := range shape { 9443 switch key { 9444 case "lambdaFunctionArn": 9445 if value != nil { 9446 jtv, ok := value.(string) 9447 if !ok { 9448 return fmt.Errorf("expected LambdaFunctionArn to be of type string, got %T instead", value) 9449 } 9450 sv.LambdaFunctionArn = ptr.String(jtv) 9451 } 9452 9453 default: 9454 _, _ = key, value 9455 9456 } 9457 } 9458 *v = sv 9459 return nil 9460} 9461 9462func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { 9463 if v == nil { 9464 return fmt.Errorf("unexpected nil of type %T", v) 9465 } 9466 if value == nil { 9467 return nil 9468 } 9469 9470 shape, ok := value.(map[string]interface{}) 9471 if !ok { 9472 return fmt.Errorf("unexpected JSON type %v", value) 9473 } 9474 9475 var sv *types.LimitExceededException 9476 if *v == nil { 9477 sv = &types.LimitExceededException{} 9478 } else { 9479 sv = *v 9480 } 9481 9482 for key, value := range shape { 9483 switch key { 9484 case "message": 9485 if value != nil { 9486 jtv, ok := value.(string) 9487 if !ok { 9488 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9489 } 9490 sv.Message = ptr.String(jtv) 9491 } 9492 9493 default: 9494 _, _ = key, value 9495 9496 } 9497 } 9498 *v = sv 9499 return nil 9500} 9501 9502func awsAwsjson11_deserializeDocumentListWebhookItem(v **types.ListWebhookItem, value interface{}) error { 9503 if v == nil { 9504 return fmt.Errorf("unexpected nil of type %T", v) 9505 } 9506 if value == nil { 9507 return nil 9508 } 9509 9510 shape, ok := value.(map[string]interface{}) 9511 if !ok { 9512 return fmt.Errorf("unexpected JSON type %v", value) 9513 } 9514 9515 var sv *types.ListWebhookItem 9516 if *v == nil { 9517 sv = &types.ListWebhookItem{} 9518 } else { 9519 sv = *v 9520 } 9521 9522 for key, value := range shape { 9523 switch key { 9524 case "arn": 9525 if value != nil { 9526 jtv, ok := value.(string) 9527 if !ok { 9528 return fmt.Errorf("expected WebhookArn to be of type string, got %T instead", value) 9529 } 9530 sv.Arn = ptr.String(jtv) 9531 } 9532 9533 case "definition": 9534 if err := awsAwsjson11_deserializeDocumentWebhookDefinition(&sv.Definition, value); err != nil { 9535 return err 9536 } 9537 9538 case "errorCode": 9539 if value != nil { 9540 jtv, ok := value.(string) 9541 if !ok { 9542 return fmt.Errorf("expected WebhookErrorCode to be of type string, got %T instead", value) 9543 } 9544 sv.ErrorCode = ptr.String(jtv) 9545 } 9546 9547 case "errorMessage": 9548 if value != nil { 9549 jtv, ok := value.(string) 9550 if !ok { 9551 return fmt.Errorf("expected WebhookErrorMessage to be of type string, got %T instead", value) 9552 } 9553 sv.ErrorMessage = ptr.String(jtv) 9554 } 9555 9556 case "lastTriggered": 9557 if value != nil { 9558 switch jtv := value.(type) { 9559 case json.Number: 9560 f64, err := jtv.Float64() 9561 if err != nil { 9562 return err 9563 } 9564 sv.LastTriggered = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9565 9566 default: 9567 return fmt.Errorf("expected WebhookLastTriggered to be a JSON Number, got %T instead", value) 9568 9569 } 9570 } 9571 9572 case "tags": 9573 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil { 9574 return err 9575 } 9576 9577 case "url": 9578 if value != nil { 9579 jtv, ok := value.(string) 9580 if !ok { 9581 return fmt.Errorf("expected WebhookUrl to be of type string, got %T instead", value) 9582 } 9583 sv.Url = ptr.String(jtv) 9584 } 9585 9586 default: 9587 _, _ = key, value 9588 9589 } 9590 } 9591 *v = sv 9592 return nil 9593} 9594 9595func awsAwsjson11_deserializeDocumentNotLatestPipelineExecutionException(v **types.NotLatestPipelineExecutionException, value interface{}) error { 9596 if v == nil { 9597 return fmt.Errorf("unexpected nil of type %T", v) 9598 } 9599 if value == nil { 9600 return nil 9601 } 9602 9603 shape, ok := value.(map[string]interface{}) 9604 if !ok { 9605 return fmt.Errorf("unexpected JSON type %v", value) 9606 } 9607 9608 var sv *types.NotLatestPipelineExecutionException 9609 if *v == nil { 9610 sv = &types.NotLatestPipelineExecutionException{} 9611 } else { 9612 sv = *v 9613 } 9614 9615 for key, value := range shape { 9616 switch key { 9617 case "message": 9618 if value != nil { 9619 jtv, ok := value.(string) 9620 if !ok { 9621 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9622 } 9623 sv.Message = ptr.String(jtv) 9624 } 9625 9626 default: 9627 _, _ = key, value 9628 9629 } 9630 } 9631 *v = sv 9632 return nil 9633} 9634 9635func awsAwsjson11_deserializeDocumentOutputArtifact(v **types.OutputArtifact, value interface{}) error { 9636 if v == nil { 9637 return fmt.Errorf("unexpected nil of type %T", v) 9638 } 9639 if value == nil { 9640 return nil 9641 } 9642 9643 shape, ok := value.(map[string]interface{}) 9644 if !ok { 9645 return fmt.Errorf("unexpected JSON type %v", value) 9646 } 9647 9648 var sv *types.OutputArtifact 9649 if *v == nil { 9650 sv = &types.OutputArtifact{} 9651 } else { 9652 sv = *v 9653 } 9654 9655 for key, value := range shape { 9656 switch key { 9657 case "name": 9658 if value != nil { 9659 jtv, ok := value.(string) 9660 if !ok { 9661 return fmt.Errorf("expected ArtifactName to be of type string, got %T instead", value) 9662 } 9663 sv.Name = ptr.String(jtv) 9664 } 9665 9666 default: 9667 _, _ = key, value 9668 9669 } 9670 } 9671 *v = sv 9672 return nil 9673} 9674 9675func awsAwsjson11_deserializeDocumentOutputArtifactList(v *[]types.OutputArtifact, value interface{}) error { 9676 if v == nil { 9677 return fmt.Errorf("unexpected nil of type %T", v) 9678 } 9679 if value == nil { 9680 return nil 9681 } 9682 9683 shape, ok := value.([]interface{}) 9684 if !ok { 9685 return fmt.Errorf("unexpected JSON type %v", value) 9686 } 9687 9688 var cv []types.OutputArtifact 9689 if *v == nil { 9690 cv = []types.OutputArtifact{} 9691 } else { 9692 cv = *v 9693 } 9694 9695 for _, value := range shape { 9696 var col types.OutputArtifact 9697 destAddr := &col 9698 if err := awsAwsjson11_deserializeDocumentOutputArtifact(&destAddr, value); err != nil { 9699 return err 9700 } 9701 col = *destAddr 9702 cv = append(cv, col) 9703 9704 } 9705 *v = cv 9706 return nil 9707} 9708 9709func awsAwsjson11_deserializeDocumentOutputVariablesMap(v *map[string]string, value interface{}) error { 9710 if v == nil { 9711 return fmt.Errorf("unexpected nil of type %T", v) 9712 } 9713 if value == nil { 9714 return nil 9715 } 9716 9717 shape, ok := value.(map[string]interface{}) 9718 if !ok { 9719 return fmt.Errorf("unexpected JSON type %v", value) 9720 } 9721 9722 var mv map[string]string 9723 if *v == nil { 9724 mv = map[string]string{} 9725 } else { 9726 mv = *v 9727 } 9728 9729 for key, value := range shape { 9730 var parsedVal string 9731 if value != nil { 9732 jtv, ok := value.(string) 9733 if !ok { 9734 return fmt.Errorf("expected OutputVariablesValue to be of type string, got %T instead", value) 9735 } 9736 parsedVal = jtv 9737 } 9738 mv[key] = parsedVal 9739 9740 } 9741 *v = mv 9742 return nil 9743} 9744 9745func awsAwsjson11_deserializeDocumentOutputVariablesSizeExceededException(v **types.OutputVariablesSizeExceededException, value interface{}) error { 9746 if v == nil { 9747 return fmt.Errorf("unexpected nil of type %T", v) 9748 } 9749 if value == nil { 9750 return nil 9751 } 9752 9753 shape, ok := value.(map[string]interface{}) 9754 if !ok { 9755 return fmt.Errorf("unexpected JSON type %v", value) 9756 } 9757 9758 var sv *types.OutputVariablesSizeExceededException 9759 if *v == nil { 9760 sv = &types.OutputVariablesSizeExceededException{} 9761 } else { 9762 sv = *v 9763 } 9764 9765 for key, value := range shape { 9766 switch key { 9767 case "message": 9768 if value != nil { 9769 jtv, ok := value.(string) 9770 if !ok { 9771 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9772 } 9773 sv.Message = ptr.String(jtv) 9774 } 9775 9776 default: 9777 _, _ = key, value 9778 9779 } 9780 } 9781 *v = sv 9782 return nil 9783} 9784 9785func awsAwsjson11_deserializeDocumentPipelineContext(v **types.PipelineContext, value interface{}) error { 9786 if v == nil { 9787 return fmt.Errorf("unexpected nil of type %T", v) 9788 } 9789 if value == nil { 9790 return nil 9791 } 9792 9793 shape, ok := value.(map[string]interface{}) 9794 if !ok { 9795 return fmt.Errorf("unexpected JSON type %v", value) 9796 } 9797 9798 var sv *types.PipelineContext 9799 if *v == nil { 9800 sv = &types.PipelineContext{} 9801 } else { 9802 sv = *v 9803 } 9804 9805 for key, value := range shape { 9806 switch key { 9807 case "action": 9808 if err := awsAwsjson11_deserializeDocumentActionContext(&sv.Action, value); err != nil { 9809 return err 9810 } 9811 9812 case "pipelineArn": 9813 if value != nil { 9814 jtv, ok := value.(string) 9815 if !ok { 9816 return fmt.Errorf("expected PipelineArn to be of type string, got %T instead", value) 9817 } 9818 sv.PipelineArn = ptr.String(jtv) 9819 } 9820 9821 case "pipelineExecutionId": 9822 if value != nil { 9823 jtv, ok := value.(string) 9824 if !ok { 9825 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 9826 } 9827 sv.PipelineExecutionId = ptr.String(jtv) 9828 } 9829 9830 case "pipelineName": 9831 if value != nil { 9832 jtv, ok := value.(string) 9833 if !ok { 9834 return fmt.Errorf("expected PipelineName to be of type string, got %T instead", value) 9835 } 9836 sv.PipelineName = ptr.String(jtv) 9837 } 9838 9839 case "stage": 9840 if err := awsAwsjson11_deserializeDocumentStageContext(&sv.Stage, value); err != nil { 9841 return err 9842 } 9843 9844 default: 9845 _, _ = key, value 9846 9847 } 9848 } 9849 *v = sv 9850 return nil 9851} 9852 9853func awsAwsjson11_deserializeDocumentPipelineDeclaration(v **types.PipelineDeclaration, value interface{}) error { 9854 if v == nil { 9855 return fmt.Errorf("unexpected nil of type %T", v) 9856 } 9857 if value == nil { 9858 return nil 9859 } 9860 9861 shape, ok := value.(map[string]interface{}) 9862 if !ok { 9863 return fmt.Errorf("unexpected JSON type %v", value) 9864 } 9865 9866 var sv *types.PipelineDeclaration 9867 if *v == nil { 9868 sv = &types.PipelineDeclaration{} 9869 } else { 9870 sv = *v 9871 } 9872 9873 for key, value := range shape { 9874 switch key { 9875 case "artifactStore": 9876 if err := awsAwsjson11_deserializeDocumentArtifactStore(&sv.ArtifactStore, value); err != nil { 9877 return err 9878 } 9879 9880 case "artifactStores": 9881 if err := awsAwsjson11_deserializeDocumentArtifactStoreMap(&sv.ArtifactStores, value); err != nil { 9882 return err 9883 } 9884 9885 case "name": 9886 if value != nil { 9887 jtv, ok := value.(string) 9888 if !ok { 9889 return fmt.Errorf("expected PipelineName to be of type string, got %T instead", value) 9890 } 9891 sv.Name = ptr.String(jtv) 9892 } 9893 9894 case "roleArn": 9895 if value != nil { 9896 jtv, ok := value.(string) 9897 if !ok { 9898 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 9899 } 9900 sv.RoleArn = ptr.String(jtv) 9901 } 9902 9903 case "stages": 9904 if err := awsAwsjson11_deserializeDocumentPipelineStageDeclarationList(&sv.Stages, value); err != nil { 9905 return err 9906 } 9907 9908 case "version": 9909 if value != nil { 9910 jtv, ok := value.(json.Number) 9911 if !ok { 9912 return fmt.Errorf("expected PipelineVersion to be json.Number, got %T instead", value) 9913 } 9914 i64, err := jtv.Int64() 9915 if err != nil { 9916 return err 9917 } 9918 sv.Version = ptr.Int32(int32(i64)) 9919 } 9920 9921 default: 9922 _, _ = key, value 9923 9924 } 9925 } 9926 *v = sv 9927 return nil 9928} 9929 9930func awsAwsjson11_deserializeDocumentPipelineExecution(v **types.PipelineExecution, value interface{}) error { 9931 if v == nil { 9932 return fmt.Errorf("unexpected nil of type %T", v) 9933 } 9934 if value == nil { 9935 return nil 9936 } 9937 9938 shape, ok := value.(map[string]interface{}) 9939 if !ok { 9940 return fmt.Errorf("unexpected JSON type %v", value) 9941 } 9942 9943 var sv *types.PipelineExecution 9944 if *v == nil { 9945 sv = &types.PipelineExecution{} 9946 } else { 9947 sv = *v 9948 } 9949 9950 for key, value := range shape { 9951 switch key { 9952 case "artifactRevisions": 9953 if err := awsAwsjson11_deserializeDocumentArtifactRevisionList(&sv.ArtifactRevisions, value); err != nil { 9954 return err 9955 } 9956 9957 case "pipelineExecutionId": 9958 if value != nil { 9959 jtv, ok := value.(string) 9960 if !ok { 9961 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 9962 } 9963 sv.PipelineExecutionId = ptr.String(jtv) 9964 } 9965 9966 case "pipelineName": 9967 if value != nil { 9968 jtv, ok := value.(string) 9969 if !ok { 9970 return fmt.Errorf("expected PipelineName to be of type string, got %T instead", value) 9971 } 9972 sv.PipelineName = ptr.String(jtv) 9973 } 9974 9975 case "pipelineVersion": 9976 if value != nil { 9977 jtv, ok := value.(json.Number) 9978 if !ok { 9979 return fmt.Errorf("expected PipelineVersion to be json.Number, got %T instead", value) 9980 } 9981 i64, err := jtv.Int64() 9982 if err != nil { 9983 return err 9984 } 9985 sv.PipelineVersion = ptr.Int32(int32(i64)) 9986 } 9987 9988 case "status": 9989 if value != nil { 9990 jtv, ok := value.(string) 9991 if !ok { 9992 return fmt.Errorf("expected PipelineExecutionStatus to be of type string, got %T instead", value) 9993 } 9994 sv.Status = types.PipelineExecutionStatus(jtv) 9995 } 9996 9997 case "statusSummary": 9998 if value != nil { 9999 jtv, ok := value.(string) 10000 if !ok { 10001 return fmt.Errorf("expected PipelineExecutionStatusSummary to be of type string, got %T instead", value) 10002 } 10003 sv.StatusSummary = ptr.String(jtv) 10004 } 10005 10006 default: 10007 _, _ = key, value 10008 10009 } 10010 } 10011 *v = sv 10012 return nil 10013} 10014 10015func awsAwsjson11_deserializeDocumentPipelineExecutionNotFoundException(v **types.PipelineExecutionNotFoundException, value interface{}) error { 10016 if v == nil { 10017 return fmt.Errorf("unexpected nil of type %T", v) 10018 } 10019 if value == nil { 10020 return nil 10021 } 10022 10023 shape, ok := value.(map[string]interface{}) 10024 if !ok { 10025 return fmt.Errorf("unexpected JSON type %v", value) 10026 } 10027 10028 var sv *types.PipelineExecutionNotFoundException 10029 if *v == nil { 10030 sv = &types.PipelineExecutionNotFoundException{} 10031 } else { 10032 sv = *v 10033 } 10034 10035 for key, value := range shape { 10036 switch key { 10037 case "message": 10038 if value != nil { 10039 jtv, ok := value.(string) 10040 if !ok { 10041 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 10042 } 10043 sv.Message = ptr.String(jtv) 10044 } 10045 10046 default: 10047 _, _ = key, value 10048 10049 } 10050 } 10051 *v = sv 10052 return nil 10053} 10054 10055func awsAwsjson11_deserializeDocumentPipelineExecutionNotStoppableException(v **types.PipelineExecutionNotStoppableException, value interface{}) error { 10056 if v == nil { 10057 return fmt.Errorf("unexpected nil of type %T", v) 10058 } 10059 if value == nil { 10060 return nil 10061 } 10062 10063 shape, ok := value.(map[string]interface{}) 10064 if !ok { 10065 return fmt.Errorf("unexpected JSON type %v", value) 10066 } 10067 10068 var sv *types.PipelineExecutionNotStoppableException 10069 if *v == nil { 10070 sv = &types.PipelineExecutionNotStoppableException{} 10071 } else { 10072 sv = *v 10073 } 10074 10075 for key, value := range shape { 10076 switch key { 10077 case "message": 10078 if value != nil { 10079 jtv, ok := value.(string) 10080 if !ok { 10081 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 10082 } 10083 sv.Message = ptr.String(jtv) 10084 } 10085 10086 default: 10087 _, _ = key, value 10088 10089 } 10090 } 10091 *v = sv 10092 return nil 10093} 10094 10095func awsAwsjson11_deserializeDocumentPipelineExecutionSummary(v **types.PipelineExecutionSummary, value interface{}) error { 10096 if v == nil { 10097 return fmt.Errorf("unexpected nil of type %T", v) 10098 } 10099 if value == nil { 10100 return nil 10101 } 10102 10103 shape, ok := value.(map[string]interface{}) 10104 if !ok { 10105 return fmt.Errorf("unexpected JSON type %v", value) 10106 } 10107 10108 var sv *types.PipelineExecutionSummary 10109 if *v == nil { 10110 sv = &types.PipelineExecutionSummary{} 10111 } else { 10112 sv = *v 10113 } 10114 10115 for key, value := range shape { 10116 switch key { 10117 case "lastUpdateTime": 10118 if value != nil { 10119 switch jtv := value.(type) { 10120 case json.Number: 10121 f64, err := jtv.Float64() 10122 if err != nil { 10123 return err 10124 } 10125 sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10126 10127 default: 10128 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 10129 10130 } 10131 } 10132 10133 case "pipelineExecutionId": 10134 if value != nil { 10135 jtv, ok := value.(string) 10136 if !ok { 10137 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 10138 } 10139 sv.PipelineExecutionId = ptr.String(jtv) 10140 } 10141 10142 case "sourceRevisions": 10143 if err := awsAwsjson11_deserializeDocumentSourceRevisionList(&sv.SourceRevisions, value); err != nil { 10144 return err 10145 } 10146 10147 case "startTime": 10148 if value != nil { 10149 switch jtv := value.(type) { 10150 case json.Number: 10151 f64, err := jtv.Float64() 10152 if err != nil { 10153 return err 10154 } 10155 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10156 10157 default: 10158 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 10159 10160 } 10161 } 10162 10163 case "status": 10164 if value != nil { 10165 jtv, ok := value.(string) 10166 if !ok { 10167 return fmt.Errorf("expected PipelineExecutionStatus to be of type string, got %T instead", value) 10168 } 10169 sv.Status = types.PipelineExecutionStatus(jtv) 10170 } 10171 10172 case "stopTrigger": 10173 if err := awsAwsjson11_deserializeDocumentStopExecutionTrigger(&sv.StopTrigger, value); err != nil { 10174 return err 10175 } 10176 10177 case "trigger": 10178 if err := awsAwsjson11_deserializeDocumentExecutionTrigger(&sv.Trigger, value); err != nil { 10179 return err 10180 } 10181 10182 default: 10183 _, _ = key, value 10184 10185 } 10186 } 10187 *v = sv 10188 return nil 10189} 10190 10191func awsAwsjson11_deserializeDocumentPipelineExecutionSummaryList(v *[]types.PipelineExecutionSummary, value interface{}) error { 10192 if v == nil { 10193 return fmt.Errorf("unexpected nil of type %T", v) 10194 } 10195 if value == nil { 10196 return nil 10197 } 10198 10199 shape, ok := value.([]interface{}) 10200 if !ok { 10201 return fmt.Errorf("unexpected JSON type %v", value) 10202 } 10203 10204 var cv []types.PipelineExecutionSummary 10205 if *v == nil { 10206 cv = []types.PipelineExecutionSummary{} 10207 } else { 10208 cv = *v 10209 } 10210 10211 for _, value := range shape { 10212 var col types.PipelineExecutionSummary 10213 destAddr := &col 10214 if err := awsAwsjson11_deserializeDocumentPipelineExecutionSummary(&destAddr, value); err != nil { 10215 return err 10216 } 10217 col = *destAddr 10218 cv = append(cv, col) 10219 10220 } 10221 *v = cv 10222 return nil 10223} 10224 10225func awsAwsjson11_deserializeDocumentPipelineList(v *[]types.PipelineSummary, value interface{}) error { 10226 if v == nil { 10227 return fmt.Errorf("unexpected nil of type %T", v) 10228 } 10229 if value == nil { 10230 return nil 10231 } 10232 10233 shape, ok := value.([]interface{}) 10234 if !ok { 10235 return fmt.Errorf("unexpected JSON type %v", value) 10236 } 10237 10238 var cv []types.PipelineSummary 10239 if *v == nil { 10240 cv = []types.PipelineSummary{} 10241 } else { 10242 cv = *v 10243 } 10244 10245 for _, value := range shape { 10246 var col types.PipelineSummary 10247 destAddr := &col 10248 if err := awsAwsjson11_deserializeDocumentPipelineSummary(&destAddr, value); err != nil { 10249 return err 10250 } 10251 col = *destAddr 10252 cv = append(cv, col) 10253 10254 } 10255 *v = cv 10256 return nil 10257} 10258 10259func awsAwsjson11_deserializeDocumentPipelineMetadata(v **types.PipelineMetadata, value interface{}) error { 10260 if v == nil { 10261 return fmt.Errorf("unexpected nil of type %T", v) 10262 } 10263 if value == nil { 10264 return nil 10265 } 10266 10267 shape, ok := value.(map[string]interface{}) 10268 if !ok { 10269 return fmt.Errorf("unexpected JSON type %v", value) 10270 } 10271 10272 var sv *types.PipelineMetadata 10273 if *v == nil { 10274 sv = &types.PipelineMetadata{} 10275 } else { 10276 sv = *v 10277 } 10278 10279 for key, value := range shape { 10280 switch key { 10281 case "created": 10282 if value != nil { 10283 switch jtv := value.(type) { 10284 case json.Number: 10285 f64, err := jtv.Float64() 10286 if err != nil { 10287 return err 10288 } 10289 sv.Created = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10290 10291 default: 10292 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 10293 10294 } 10295 } 10296 10297 case "pipelineArn": 10298 if value != nil { 10299 jtv, ok := value.(string) 10300 if !ok { 10301 return fmt.Errorf("expected PipelineArn to be of type string, got %T instead", value) 10302 } 10303 sv.PipelineArn = ptr.String(jtv) 10304 } 10305 10306 case "updated": 10307 if value != nil { 10308 switch jtv := value.(type) { 10309 case json.Number: 10310 f64, err := jtv.Float64() 10311 if err != nil { 10312 return err 10313 } 10314 sv.Updated = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10315 10316 default: 10317 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 10318 10319 } 10320 } 10321 10322 default: 10323 _, _ = key, value 10324 10325 } 10326 } 10327 *v = sv 10328 return nil 10329} 10330 10331func awsAwsjson11_deserializeDocumentPipelineNameInUseException(v **types.PipelineNameInUseException, value interface{}) error { 10332 if v == nil { 10333 return fmt.Errorf("unexpected nil of type %T", v) 10334 } 10335 if value == nil { 10336 return nil 10337 } 10338 10339 shape, ok := value.(map[string]interface{}) 10340 if !ok { 10341 return fmt.Errorf("unexpected JSON type %v", value) 10342 } 10343 10344 var sv *types.PipelineNameInUseException 10345 if *v == nil { 10346 sv = &types.PipelineNameInUseException{} 10347 } else { 10348 sv = *v 10349 } 10350 10351 for key, value := range shape { 10352 switch key { 10353 case "message": 10354 if value != nil { 10355 jtv, ok := value.(string) 10356 if !ok { 10357 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 10358 } 10359 sv.Message = ptr.String(jtv) 10360 } 10361 10362 default: 10363 _, _ = key, value 10364 10365 } 10366 } 10367 *v = sv 10368 return nil 10369} 10370 10371func awsAwsjson11_deserializeDocumentPipelineNotFoundException(v **types.PipelineNotFoundException, value interface{}) error { 10372 if v == nil { 10373 return fmt.Errorf("unexpected nil of type %T", v) 10374 } 10375 if value == nil { 10376 return nil 10377 } 10378 10379 shape, ok := value.(map[string]interface{}) 10380 if !ok { 10381 return fmt.Errorf("unexpected JSON type %v", value) 10382 } 10383 10384 var sv *types.PipelineNotFoundException 10385 if *v == nil { 10386 sv = &types.PipelineNotFoundException{} 10387 } else { 10388 sv = *v 10389 } 10390 10391 for key, value := range shape { 10392 switch key { 10393 case "message": 10394 if value != nil { 10395 jtv, ok := value.(string) 10396 if !ok { 10397 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 10398 } 10399 sv.Message = ptr.String(jtv) 10400 } 10401 10402 default: 10403 _, _ = key, value 10404 10405 } 10406 } 10407 *v = sv 10408 return nil 10409} 10410 10411func awsAwsjson11_deserializeDocumentPipelineStageDeclarationList(v *[]types.StageDeclaration, value interface{}) error { 10412 if v == nil { 10413 return fmt.Errorf("unexpected nil of type %T", v) 10414 } 10415 if value == nil { 10416 return nil 10417 } 10418 10419 shape, ok := value.([]interface{}) 10420 if !ok { 10421 return fmt.Errorf("unexpected JSON type %v", value) 10422 } 10423 10424 var cv []types.StageDeclaration 10425 if *v == nil { 10426 cv = []types.StageDeclaration{} 10427 } else { 10428 cv = *v 10429 } 10430 10431 for _, value := range shape { 10432 var col types.StageDeclaration 10433 destAddr := &col 10434 if err := awsAwsjson11_deserializeDocumentStageDeclaration(&destAddr, value); err != nil { 10435 return err 10436 } 10437 col = *destAddr 10438 cv = append(cv, col) 10439 10440 } 10441 *v = cv 10442 return nil 10443} 10444 10445func awsAwsjson11_deserializeDocumentPipelineSummary(v **types.PipelineSummary, value interface{}) error { 10446 if v == nil { 10447 return fmt.Errorf("unexpected nil of type %T", v) 10448 } 10449 if value == nil { 10450 return nil 10451 } 10452 10453 shape, ok := value.(map[string]interface{}) 10454 if !ok { 10455 return fmt.Errorf("unexpected JSON type %v", value) 10456 } 10457 10458 var sv *types.PipelineSummary 10459 if *v == nil { 10460 sv = &types.PipelineSummary{} 10461 } else { 10462 sv = *v 10463 } 10464 10465 for key, value := range shape { 10466 switch key { 10467 case "created": 10468 if value != nil { 10469 switch jtv := value.(type) { 10470 case json.Number: 10471 f64, err := jtv.Float64() 10472 if err != nil { 10473 return err 10474 } 10475 sv.Created = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10476 10477 default: 10478 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 10479 10480 } 10481 } 10482 10483 case "name": 10484 if value != nil { 10485 jtv, ok := value.(string) 10486 if !ok { 10487 return fmt.Errorf("expected PipelineName to be of type string, got %T instead", value) 10488 } 10489 sv.Name = ptr.String(jtv) 10490 } 10491 10492 case "updated": 10493 if value != nil { 10494 switch jtv := value.(type) { 10495 case json.Number: 10496 f64, err := jtv.Float64() 10497 if err != nil { 10498 return err 10499 } 10500 sv.Updated = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10501 10502 default: 10503 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 10504 10505 } 10506 } 10507 10508 case "version": 10509 if value != nil { 10510 jtv, ok := value.(json.Number) 10511 if !ok { 10512 return fmt.Errorf("expected PipelineVersion to be json.Number, got %T instead", value) 10513 } 10514 i64, err := jtv.Int64() 10515 if err != nil { 10516 return err 10517 } 10518 sv.Version = ptr.Int32(int32(i64)) 10519 } 10520 10521 default: 10522 _, _ = key, value 10523 10524 } 10525 } 10526 *v = sv 10527 return nil 10528} 10529 10530func awsAwsjson11_deserializeDocumentPipelineVersionNotFoundException(v **types.PipelineVersionNotFoundException, value interface{}) error { 10531 if v == nil { 10532 return fmt.Errorf("unexpected nil of type %T", v) 10533 } 10534 if value == nil { 10535 return nil 10536 } 10537 10538 shape, ok := value.(map[string]interface{}) 10539 if !ok { 10540 return fmt.Errorf("unexpected JSON type %v", value) 10541 } 10542 10543 var sv *types.PipelineVersionNotFoundException 10544 if *v == nil { 10545 sv = &types.PipelineVersionNotFoundException{} 10546 } else { 10547 sv = *v 10548 } 10549 10550 for key, value := range shape { 10551 switch key { 10552 case "message": 10553 if value != nil { 10554 jtv, ok := value.(string) 10555 if !ok { 10556 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 10557 } 10558 sv.Message = ptr.String(jtv) 10559 } 10560 10561 default: 10562 _, _ = key, value 10563 10564 } 10565 } 10566 *v = sv 10567 return nil 10568} 10569 10570func awsAwsjson11_deserializeDocumentPollingAccountList(v *[]string, value interface{}) error { 10571 if v == nil { 10572 return fmt.Errorf("unexpected nil of type %T", v) 10573 } 10574 if value == nil { 10575 return nil 10576 } 10577 10578 shape, ok := value.([]interface{}) 10579 if !ok { 10580 return fmt.Errorf("unexpected JSON type %v", value) 10581 } 10582 10583 var cv []string 10584 if *v == nil { 10585 cv = []string{} 10586 } else { 10587 cv = *v 10588 } 10589 10590 for _, value := range shape { 10591 var col string 10592 if value != nil { 10593 jtv, ok := value.(string) 10594 if !ok { 10595 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 10596 } 10597 col = jtv 10598 } 10599 cv = append(cv, col) 10600 10601 } 10602 *v = cv 10603 return nil 10604} 10605 10606func awsAwsjson11_deserializeDocumentPollingServicePrincipalList(v *[]string, value interface{}) error { 10607 if v == nil { 10608 return fmt.Errorf("unexpected nil of type %T", v) 10609 } 10610 if value == nil { 10611 return nil 10612 } 10613 10614 shape, ok := value.([]interface{}) 10615 if !ok { 10616 return fmt.Errorf("unexpected JSON type %v", value) 10617 } 10618 10619 var cv []string 10620 if *v == nil { 10621 cv = []string{} 10622 } else { 10623 cv = *v 10624 } 10625 10626 for _, value := range shape { 10627 var col string 10628 if value != nil { 10629 jtv, ok := value.(string) 10630 if !ok { 10631 return fmt.Errorf("expected ServicePrincipal to be of type string, got %T instead", value) 10632 } 10633 col = jtv 10634 } 10635 cv = append(cv, col) 10636 10637 } 10638 *v = cv 10639 return nil 10640} 10641 10642func awsAwsjson11_deserializeDocumentRequestFailedException(v **types.RequestFailedException, value interface{}) error { 10643 if v == nil { 10644 return fmt.Errorf("unexpected nil of type %T", v) 10645 } 10646 if value == nil { 10647 return nil 10648 } 10649 10650 shape, ok := value.(map[string]interface{}) 10651 if !ok { 10652 return fmt.Errorf("unexpected JSON type %v", value) 10653 } 10654 10655 var sv *types.RequestFailedException 10656 if *v == nil { 10657 sv = &types.RequestFailedException{} 10658 } else { 10659 sv = *v 10660 } 10661 10662 for key, value := range shape { 10663 switch key { 10664 case "message": 10665 if value != nil { 10666 jtv, ok := value.(string) 10667 if !ok { 10668 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 10669 } 10670 sv.Message = ptr.String(jtv) 10671 } 10672 10673 default: 10674 _, _ = key, value 10675 10676 } 10677 } 10678 *v = sv 10679 return nil 10680} 10681 10682func awsAwsjson11_deserializeDocumentResolvedActionConfigurationMap(v *map[string]string, value interface{}) error { 10683 if v == nil { 10684 return fmt.Errorf("unexpected nil of type %T", v) 10685 } 10686 if value == nil { 10687 return nil 10688 } 10689 10690 shape, ok := value.(map[string]interface{}) 10691 if !ok { 10692 return fmt.Errorf("unexpected JSON type %v", value) 10693 } 10694 10695 var mv map[string]string 10696 if *v == nil { 10697 mv = map[string]string{} 10698 } else { 10699 mv = *v 10700 } 10701 10702 for key, value := range shape { 10703 var parsedVal string 10704 if value != nil { 10705 jtv, ok := value.(string) 10706 if !ok { 10707 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10708 } 10709 parsedVal = jtv 10710 } 10711 mv[key] = parsedVal 10712 10713 } 10714 *v = mv 10715 return nil 10716} 10717 10718func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 10719 if v == nil { 10720 return fmt.Errorf("unexpected nil of type %T", v) 10721 } 10722 if value == nil { 10723 return nil 10724 } 10725 10726 shape, ok := value.(map[string]interface{}) 10727 if !ok { 10728 return fmt.Errorf("unexpected JSON type %v", value) 10729 } 10730 10731 var sv *types.ResourceNotFoundException 10732 if *v == nil { 10733 sv = &types.ResourceNotFoundException{} 10734 } else { 10735 sv = *v 10736 } 10737 10738 for key, value := range shape { 10739 switch key { 10740 case "message": 10741 if value != nil { 10742 jtv, ok := value.(string) 10743 if !ok { 10744 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 10745 } 10746 sv.Message = ptr.String(jtv) 10747 } 10748 10749 default: 10750 _, _ = key, value 10751 10752 } 10753 } 10754 *v = sv 10755 return nil 10756} 10757 10758func awsAwsjson11_deserializeDocumentS3ArtifactLocation(v **types.S3ArtifactLocation, value interface{}) error { 10759 if v == nil { 10760 return fmt.Errorf("unexpected nil of type %T", v) 10761 } 10762 if value == nil { 10763 return nil 10764 } 10765 10766 shape, ok := value.(map[string]interface{}) 10767 if !ok { 10768 return fmt.Errorf("unexpected JSON type %v", value) 10769 } 10770 10771 var sv *types.S3ArtifactLocation 10772 if *v == nil { 10773 sv = &types.S3ArtifactLocation{} 10774 } else { 10775 sv = *v 10776 } 10777 10778 for key, value := range shape { 10779 switch key { 10780 case "bucketName": 10781 if value != nil { 10782 jtv, ok := value.(string) 10783 if !ok { 10784 return fmt.Errorf("expected S3BucketName to be of type string, got %T instead", value) 10785 } 10786 sv.BucketName = ptr.String(jtv) 10787 } 10788 10789 case "objectKey": 10790 if value != nil { 10791 jtv, ok := value.(string) 10792 if !ok { 10793 return fmt.Errorf("expected S3ObjectKey to be of type string, got %T instead", value) 10794 } 10795 sv.ObjectKey = ptr.String(jtv) 10796 } 10797 10798 default: 10799 _, _ = key, value 10800 10801 } 10802 } 10803 *v = sv 10804 return nil 10805} 10806 10807func awsAwsjson11_deserializeDocumentS3Location(v **types.S3Location, value interface{}) error { 10808 if v == nil { 10809 return fmt.Errorf("unexpected nil of type %T", v) 10810 } 10811 if value == nil { 10812 return nil 10813 } 10814 10815 shape, ok := value.(map[string]interface{}) 10816 if !ok { 10817 return fmt.Errorf("unexpected JSON type %v", value) 10818 } 10819 10820 var sv *types.S3Location 10821 if *v == nil { 10822 sv = &types.S3Location{} 10823 } else { 10824 sv = *v 10825 } 10826 10827 for key, value := range shape { 10828 switch key { 10829 case "bucket": 10830 if value != nil { 10831 jtv, ok := value.(string) 10832 if !ok { 10833 return fmt.Errorf("expected S3Bucket to be of type string, got %T instead", value) 10834 } 10835 sv.Bucket = ptr.String(jtv) 10836 } 10837 10838 case "key": 10839 if value != nil { 10840 jtv, ok := value.(string) 10841 if !ok { 10842 return fmt.Errorf("expected S3Key to be of type string, got %T instead", value) 10843 } 10844 sv.Key = ptr.String(jtv) 10845 } 10846 10847 default: 10848 _, _ = key, value 10849 10850 } 10851 } 10852 *v = sv 10853 return nil 10854} 10855 10856func awsAwsjson11_deserializeDocumentSourceRevision(v **types.SourceRevision, value interface{}) error { 10857 if v == nil { 10858 return fmt.Errorf("unexpected nil of type %T", v) 10859 } 10860 if value == nil { 10861 return nil 10862 } 10863 10864 shape, ok := value.(map[string]interface{}) 10865 if !ok { 10866 return fmt.Errorf("unexpected JSON type %v", value) 10867 } 10868 10869 var sv *types.SourceRevision 10870 if *v == nil { 10871 sv = &types.SourceRevision{} 10872 } else { 10873 sv = *v 10874 } 10875 10876 for key, value := range shape { 10877 switch key { 10878 case "actionName": 10879 if value != nil { 10880 jtv, ok := value.(string) 10881 if !ok { 10882 return fmt.Errorf("expected ActionName to be of type string, got %T instead", value) 10883 } 10884 sv.ActionName = ptr.String(jtv) 10885 } 10886 10887 case "revisionId": 10888 if value != nil { 10889 jtv, ok := value.(string) 10890 if !ok { 10891 return fmt.Errorf("expected Revision to be of type string, got %T instead", value) 10892 } 10893 sv.RevisionId = ptr.String(jtv) 10894 } 10895 10896 case "revisionSummary": 10897 if value != nil { 10898 jtv, ok := value.(string) 10899 if !ok { 10900 return fmt.Errorf("expected RevisionSummary to be of type string, got %T instead", value) 10901 } 10902 sv.RevisionSummary = ptr.String(jtv) 10903 } 10904 10905 case "revisionUrl": 10906 if value != nil { 10907 jtv, ok := value.(string) 10908 if !ok { 10909 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 10910 } 10911 sv.RevisionUrl = ptr.String(jtv) 10912 } 10913 10914 default: 10915 _, _ = key, value 10916 10917 } 10918 } 10919 *v = sv 10920 return nil 10921} 10922 10923func awsAwsjson11_deserializeDocumentSourceRevisionList(v *[]types.SourceRevision, value interface{}) error { 10924 if v == nil { 10925 return fmt.Errorf("unexpected nil of type %T", v) 10926 } 10927 if value == nil { 10928 return nil 10929 } 10930 10931 shape, ok := value.([]interface{}) 10932 if !ok { 10933 return fmt.Errorf("unexpected JSON type %v", value) 10934 } 10935 10936 var cv []types.SourceRevision 10937 if *v == nil { 10938 cv = []types.SourceRevision{} 10939 } else { 10940 cv = *v 10941 } 10942 10943 for _, value := range shape { 10944 var col types.SourceRevision 10945 destAddr := &col 10946 if err := awsAwsjson11_deserializeDocumentSourceRevision(&destAddr, value); err != nil { 10947 return err 10948 } 10949 col = *destAddr 10950 cv = append(cv, col) 10951 10952 } 10953 *v = cv 10954 return nil 10955} 10956 10957func awsAwsjson11_deserializeDocumentStageActionDeclarationList(v *[]types.ActionDeclaration, value interface{}) error { 10958 if v == nil { 10959 return fmt.Errorf("unexpected nil of type %T", v) 10960 } 10961 if value == nil { 10962 return nil 10963 } 10964 10965 shape, ok := value.([]interface{}) 10966 if !ok { 10967 return fmt.Errorf("unexpected JSON type %v", value) 10968 } 10969 10970 var cv []types.ActionDeclaration 10971 if *v == nil { 10972 cv = []types.ActionDeclaration{} 10973 } else { 10974 cv = *v 10975 } 10976 10977 for _, value := range shape { 10978 var col types.ActionDeclaration 10979 destAddr := &col 10980 if err := awsAwsjson11_deserializeDocumentActionDeclaration(&destAddr, value); err != nil { 10981 return err 10982 } 10983 col = *destAddr 10984 cv = append(cv, col) 10985 10986 } 10987 *v = cv 10988 return nil 10989} 10990 10991func awsAwsjson11_deserializeDocumentStageBlockerDeclarationList(v *[]types.BlockerDeclaration, value interface{}) error { 10992 if v == nil { 10993 return fmt.Errorf("unexpected nil of type %T", v) 10994 } 10995 if value == nil { 10996 return nil 10997 } 10998 10999 shape, ok := value.([]interface{}) 11000 if !ok { 11001 return fmt.Errorf("unexpected JSON type %v", value) 11002 } 11003 11004 var cv []types.BlockerDeclaration 11005 if *v == nil { 11006 cv = []types.BlockerDeclaration{} 11007 } else { 11008 cv = *v 11009 } 11010 11011 for _, value := range shape { 11012 var col types.BlockerDeclaration 11013 destAddr := &col 11014 if err := awsAwsjson11_deserializeDocumentBlockerDeclaration(&destAddr, value); err != nil { 11015 return err 11016 } 11017 col = *destAddr 11018 cv = append(cv, col) 11019 11020 } 11021 *v = cv 11022 return nil 11023} 11024 11025func awsAwsjson11_deserializeDocumentStageContext(v **types.StageContext, value interface{}) error { 11026 if v == nil { 11027 return fmt.Errorf("unexpected nil of type %T", v) 11028 } 11029 if value == nil { 11030 return nil 11031 } 11032 11033 shape, ok := value.(map[string]interface{}) 11034 if !ok { 11035 return fmt.Errorf("unexpected JSON type %v", value) 11036 } 11037 11038 var sv *types.StageContext 11039 if *v == nil { 11040 sv = &types.StageContext{} 11041 } else { 11042 sv = *v 11043 } 11044 11045 for key, value := range shape { 11046 switch key { 11047 case "name": 11048 if value != nil { 11049 jtv, ok := value.(string) 11050 if !ok { 11051 return fmt.Errorf("expected StageName to be of type string, got %T instead", value) 11052 } 11053 sv.Name = ptr.String(jtv) 11054 } 11055 11056 default: 11057 _, _ = key, value 11058 11059 } 11060 } 11061 *v = sv 11062 return nil 11063} 11064 11065func awsAwsjson11_deserializeDocumentStageDeclaration(v **types.StageDeclaration, value interface{}) error { 11066 if v == nil { 11067 return fmt.Errorf("unexpected nil of type %T", v) 11068 } 11069 if value == nil { 11070 return nil 11071 } 11072 11073 shape, ok := value.(map[string]interface{}) 11074 if !ok { 11075 return fmt.Errorf("unexpected JSON type %v", value) 11076 } 11077 11078 var sv *types.StageDeclaration 11079 if *v == nil { 11080 sv = &types.StageDeclaration{} 11081 } else { 11082 sv = *v 11083 } 11084 11085 for key, value := range shape { 11086 switch key { 11087 case "actions": 11088 if err := awsAwsjson11_deserializeDocumentStageActionDeclarationList(&sv.Actions, value); err != nil { 11089 return err 11090 } 11091 11092 case "blockers": 11093 if err := awsAwsjson11_deserializeDocumentStageBlockerDeclarationList(&sv.Blockers, value); err != nil { 11094 return err 11095 } 11096 11097 case "name": 11098 if value != nil { 11099 jtv, ok := value.(string) 11100 if !ok { 11101 return fmt.Errorf("expected StageName to be of type string, got %T instead", value) 11102 } 11103 sv.Name = ptr.String(jtv) 11104 } 11105 11106 default: 11107 _, _ = key, value 11108 11109 } 11110 } 11111 *v = sv 11112 return nil 11113} 11114 11115func awsAwsjson11_deserializeDocumentStageExecution(v **types.StageExecution, value interface{}) error { 11116 if v == nil { 11117 return fmt.Errorf("unexpected nil of type %T", v) 11118 } 11119 if value == nil { 11120 return nil 11121 } 11122 11123 shape, ok := value.(map[string]interface{}) 11124 if !ok { 11125 return fmt.Errorf("unexpected JSON type %v", value) 11126 } 11127 11128 var sv *types.StageExecution 11129 if *v == nil { 11130 sv = &types.StageExecution{} 11131 } else { 11132 sv = *v 11133 } 11134 11135 for key, value := range shape { 11136 switch key { 11137 case "pipelineExecutionId": 11138 if value != nil { 11139 jtv, ok := value.(string) 11140 if !ok { 11141 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 11142 } 11143 sv.PipelineExecutionId = ptr.String(jtv) 11144 } 11145 11146 case "status": 11147 if value != nil { 11148 jtv, ok := value.(string) 11149 if !ok { 11150 return fmt.Errorf("expected StageExecutionStatus to be of type string, got %T instead", value) 11151 } 11152 sv.Status = types.StageExecutionStatus(jtv) 11153 } 11154 11155 default: 11156 _, _ = key, value 11157 11158 } 11159 } 11160 *v = sv 11161 return nil 11162} 11163 11164func awsAwsjson11_deserializeDocumentStageNotFoundException(v **types.StageNotFoundException, value interface{}) error { 11165 if v == nil { 11166 return fmt.Errorf("unexpected nil of type %T", v) 11167 } 11168 if value == nil { 11169 return nil 11170 } 11171 11172 shape, ok := value.(map[string]interface{}) 11173 if !ok { 11174 return fmt.Errorf("unexpected JSON type %v", value) 11175 } 11176 11177 var sv *types.StageNotFoundException 11178 if *v == nil { 11179 sv = &types.StageNotFoundException{} 11180 } else { 11181 sv = *v 11182 } 11183 11184 for key, value := range shape { 11185 switch key { 11186 case "message": 11187 if value != nil { 11188 jtv, ok := value.(string) 11189 if !ok { 11190 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 11191 } 11192 sv.Message = ptr.String(jtv) 11193 } 11194 11195 default: 11196 _, _ = key, value 11197 11198 } 11199 } 11200 *v = sv 11201 return nil 11202} 11203 11204func awsAwsjson11_deserializeDocumentStageNotRetryableException(v **types.StageNotRetryableException, value interface{}) error { 11205 if v == nil { 11206 return fmt.Errorf("unexpected nil of type %T", v) 11207 } 11208 if value == nil { 11209 return nil 11210 } 11211 11212 shape, ok := value.(map[string]interface{}) 11213 if !ok { 11214 return fmt.Errorf("unexpected JSON type %v", value) 11215 } 11216 11217 var sv *types.StageNotRetryableException 11218 if *v == nil { 11219 sv = &types.StageNotRetryableException{} 11220 } else { 11221 sv = *v 11222 } 11223 11224 for key, value := range shape { 11225 switch key { 11226 case "message": 11227 if value != nil { 11228 jtv, ok := value.(string) 11229 if !ok { 11230 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 11231 } 11232 sv.Message = ptr.String(jtv) 11233 } 11234 11235 default: 11236 _, _ = key, value 11237 11238 } 11239 } 11240 *v = sv 11241 return nil 11242} 11243 11244func awsAwsjson11_deserializeDocumentStageState(v **types.StageState, value interface{}) error { 11245 if v == nil { 11246 return fmt.Errorf("unexpected nil of type %T", v) 11247 } 11248 if value == nil { 11249 return nil 11250 } 11251 11252 shape, ok := value.(map[string]interface{}) 11253 if !ok { 11254 return fmt.Errorf("unexpected JSON type %v", value) 11255 } 11256 11257 var sv *types.StageState 11258 if *v == nil { 11259 sv = &types.StageState{} 11260 } else { 11261 sv = *v 11262 } 11263 11264 for key, value := range shape { 11265 switch key { 11266 case "actionStates": 11267 if err := awsAwsjson11_deserializeDocumentActionStateList(&sv.ActionStates, value); err != nil { 11268 return err 11269 } 11270 11271 case "inboundExecution": 11272 if err := awsAwsjson11_deserializeDocumentStageExecution(&sv.InboundExecution, value); err != nil { 11273 return err 11274 } 11275 11276 case "inboundTransitionState": 11277 if err := awsAwsjson11_deserializeDocumentTransitionState(&sv.InboundTransitionState, value); err != nil { 11278 return err 11279 } 11280 11281 case "latestExecution": 11282 if err := awsAwsjson11_deserializeDocumentStageExecution(&sv.LatestExecution, value); err != nil { 11283 return err 11284 } 11285 11286 case "stageName": 11287 if value != nil { 11288 jtv, ok := value.(string) 11289 if !ok { 11290 return fmt.Errorf("expected StageName to be of type string, got %T instead", value) 11291 } 11292 sv.StageName = ptr.String(jtv) 11293 } 11294 11295 default: 11296 _, _ = key, value 11297 11298 } 11299 } 11300 *v = sv 11301 return nil 11302} 11303 11304func awsAwsjson11_deserializeDocumentStageStateList(v *[]types.StageState, value interface{}) error { 11305 if v == nil { 11306 return fmt.Errorf("unexpected nil of type %T", v) 11307 } 11308 if value == nil { 11309 return nil 11310 } 11311 11312 shape, ok := value.([]interface{}) 11313 if !ok { 11314 return fmt.Errorf("unexpected JSON type %v", value) 11315 } 11316 11317 var cv []types.StageState 11318 if *v == nil { 11319 cv = []types.StageState{} 11320 } else { 11321 cv = *v 11322 } 11323 11324 for _, value := range shape { 11325 var col types.StageState 11326 destAddr := &col 11327 if err := awsAwsjson11_deserializeDocumentStageState(&destAddr, value); err != nil { 11328 return err 11329 } 11330 col = *destAddr 11331 cv = append(cv, col) 11332 11333 } 11334 *v = cv 11335 return nil 11336} 11337 11338func awsAwsjson11_deserializeDocumentStopExecutionTrigger(v **types.StopExecutionTrigger, value interface{}) error { 11339 if v == nil { 11340 return fmt.Errorf("unexpected nil of type %T", v) 11341 } 11342 if value == nil { 11343 return nil 11344 } 11345 11346 shape, ok := value.(map[string]interface{}) 11347 if !ok { 11348 return fmt.Errorf("unexpected JSON type %v", value) 11349 } 11350 11351 var sv *types.StopExecutionTrigger 11352 if *v == nil { 11353 sv = &types.StopExecutionTrigger{} 11354 } else { 11355 sv = *v 11356 } 11357 11358 for key, value := range shape { 11359 switch key { 11360 case "reason": 11361 if value != nil { 11362 jtv, ok := value.(string) 11363 if !ok { 11364 return fmt.Errorf("expected StopPipelineExecutionReason to be of type string, got %T instead", value) 11365 } 11366 sv.Reason = ptr.String(jtv) 11367 } 11368 11369 default: 11370 _, _ = key, value 11371 11372 } 11373 } 11374 *v = sv 11375 return nil 11376} 11377 11378func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 11379 if v == nil { 11380 return fmt.Errorf("unexpected nil of type %T", v) 11381 } 11382 if value == nil { 11383 return nil 11384 } 11385 11386 shape, ok := value.(map[string]interface{}) 11387 if !ok { 11388 return fmt.Errorf("unexpected JSON type %v", value) 11389 } 11390 11391 var sv *types.Tag 11392 if *v == nil { 11393 sv = &types.Tag{} 11394 } else { 11395 sv = *v 11396 } 11397 11398 for key, value := range shape { 11399 switch key { 11400 case "key": 11401 if value != nil { 11402 jtv, ok := value.(string) 11403 if !ok { 11404 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 11405 } 11406 sv.Key = ptr.String(jtv) 11407 } 11408 11409 case "value": 11410 if value != nil { 11411 jtv, ok := value.(string) 11412 if !ok { 11413 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 11414 } 11415 sv.Value = ptr.String(jtv) 11416 } 11417 11418 default: 11419 _, _ = key, value 11420 11421 } 11422 } 11423 *v = sv 11424 return nil 11425} 11426 11427func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error { 11428 if v == nil { 11429 return fmt.Errorf("unexpected nil of type %T", v) 11430 } 11431 if value == nil { 11432 return nil 11433 } 11434 11435 shape, ok := value.([]interface{}) 11436 if !ok { 11437 return fmt.Errorf("unexpected JSON type %v", value) 11438 } 11439 11440 var cv []types.Tag 11441 if *v == nil { 11442 cv = []types.Tag{} 11443 } else { 11444 cv = *v 11445 } 11446 11447 for _, value := range shape { 11448 var col types.Tag 11449 destAddr := &col 11450 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 11451 return err 11452 } 11453 col = *destAddr 11454 cv = append(cv, col) 11455 11456 } 11457 *v = cv 11458 return nil 11459} 11460 11461func awsAwsjson11_deserializeDocumentThirdPartyJob(v **types.ThirdPartyJob, value interface{}) error { 11462 if v == nil { 11463 return fmt.Errorf("unexpected nil of type %T", v) 11464 } 11465 if value == nil { 11466 return nil 11467 } 11468 11469 shape, ok := value.(map[string]interface{}) 11470 if !ok { 11471 return fmt.Errorf("unexpected JSON type %v", value) 11472 } 11473 11474 var sv *types.ThirdPartyJob 11475 if *v == nil { 11476 sv = &types.ThirdPartyJob{} 11477 } else { 11478 sv = *v 11479 } 11480 11481 for key, value := range shape { 11482 switch key { 11483 case "clientId": 11484 if value != nil { 11485 jtv, ok := value.(string) 11486 if !ok { 11487 return fmt.Errorf("expected ClientId to be of type string, got %T instead", value) 11488 } 11489 sv.ClientId = ptr.String(jtv) 11490 } 11491 11492 case "jobId": 11493 if value != nil { 11494 jtv, ok := value.(string) 11495 if !ok { 11496 return fmt.Errorf("expected JobId to be of type string, got %T instead", value) 11497 } 11498 sv.JobId = ptr.String(jtv) 11499 } 11500 11501 default: 11502 _, _ = key, value 11503 11504 } 11505 } 11506 *v = sv 11507 return nil 11508} 11509 11510func awsAwsjson11_deserializeDocumentThirdPartyJobData(v **types.ThirdPartyJobData, value interface{}) error { 11511 if v == nil { 11512 return fmt.Errorf("unexpected nil of type %T", v) 11513 } 11514 if value == nil { 11515 return nil 11516 } 11517 11518 shape, ok := value.(map[string]interface{}) 11519 if !ok { 11520 return fmt.Errorf("unexpected JSON type %v", value) 11521 } 11522 11523 var sv *types.ThirdPartyJobData 11524 if *v == nil { 11525 sv = &types.ThirdPartyJobData{} 11526 } else { 11527 sv = *v 11528 } 11529 11530 for key, value := range shape { 11531 switch key { 11532 case "actionConfiguration": 11533 if err := awsAwsjson11_deserializeDocumentActionConfiguration(&sv.ActionConfiguration, value); err != nil { 11534 return err 11535 } 11536 11537 case "actionTypeId": 11538 if err := awsAwsjson11_deserializeDocumentActionTypeId(&sv.ActionTypeId, value); err != nil { 11539 return err 11540 } 11541 11542 case "artifactCredentials": 11543 if err := awsAwsjson11_deserializeDocumentAWSSessionCredentials(&sv.ArtifactCredentials, value); err != nil { 11544 return err 11545 } 11546 11547 case "continuationToken": 11548 if value != nil { 11549 jtv, ok := value.(string) 11550 if !ok { 11551 return fmt.Errorf("expected ContinuationToken to be of type string, got %T instead", value) 11552 } 11553 sv.ContinuationToken = ptr.String(jtv) 11554 } 11555 11556 case "encryptionKey": 11557 if err := awsAwsjson11_deserializeDocumentEncryptionKey(&sv.EncryptionKey, value); err != nil { 11558 return err 11559 } 11560 11561 case "inputArtifacts": 11562 if err := awsAwsjson11_deserializeDocumentArtifactList(&sv.InputArtifacts, value); err != nil { 11563 return err 11564 } 11565 11566 case "outputArtifacts": 11567 if err := awsAwsjson11_deserializeDocumentArtifactList(&sv.OutputArtifacts, value); err != nil { 11568 return err 11569 } 11570 11571 case "pipelineContext": 11572 if err := awsAwsjson11_deserializeDocumentPipelineContext(&sv.PipelineContext, value); err != nil { 11573 return err 11574 } 11575 11576 default: 11577 _, _ = key, value 11578 11579 } 11580 } 11581 *v = sv 11582 return nil 11583} 11584 11585func awsAwsjson11_deserializeDocumentThirdPartyJobDetails(v **types.ThirdPartyJobDetails, value interface{}) error { 11586 if v == nil { 11587 return fmt.Errorf("unexpected nil of type %T", v) 11588 } 11589 if value == nil { 11590 return nil 11591 } 11592 11593 shape, ok := value.(map[string]interface{}) 11594 if !ok { 11595 return fmt.Errorf("unexpected JSON type %v", value) 11596 } 11597 11598 var sv *types.ThirdPartyJobDetails 11599 if *v == nil { 11600 sv = &types.ThirdPartyJobDetails{} 11601 } else { 11602 sv = *v 11603 } 11604 11605 for key, value := range shape { 11606 switch key { 11607 case "data": 11608 if err := awsAwsjson11_deserializeDocumentThirdPartyJobData(&sv.Data, value); err != nil { 11609 return err 11610 } 11611 11612 case "id": 11613 if value != nil { 11614 jtv, ok := value.(string) 11615 if !ok { 11616 return fmt.Errorf("expected ThirdPartyJobId to be of type string, got %T instead", value) 11617 } 11618 sv.Id = ptr.String(jtv) 11619 } 11620 11621 case "nonce": 11622 if value != nil { 11623 jtv, ok := value.(string) 11624 if !ok { 11625 return fmt.Errorf("expected Nonce to be of type string, got %T instead", value) 11626 } 11627 sv.Nonce = ptr.String(jtv) 11628 } 11629 11630 default: 11631 _, _ = key, value 11632 11633 } 11634 } 11635 *v = sv 11636 return nil 11637} 11638 11639func awsAwsjson11_deserializeDocumentThirdPartyJobList(v *[]types.ThirdPartyJob, value interface{}) error { 11640 if v == nil { 11641 return fmt.Errorf("unexpected nil of type %T", v) 11642 } 11643 if value == nil { 11644 return nil 11645 } 11646 11647 shape, ok := value.([]interface{}) 11648 if !ok { 11649 return fmt.Errorf("unexpected JSON type %v", value) 11650 } 11651 11652 var cv []types.ThirdPartyJob 11653 if *v == nil { 11654 cv = []types.ThirdPartyJob{} 11655 } else { 11656 cv = *v 11657 } 11658 11659 for _, value := range shape { 11660 var col types.ThirdPartyJob 11661 destAddr := &col 11662 if err := awsAwsjson11_deserializeDocumentThirdPartyJob(&destAddr, value); err != nil { 11663 return err 11664 } 11665 col = *destAddr 11666 cv = append(cv, col) 11667 11668 } 11669 *v = cv 11670 return nil 11671} 11672 11673func awsAwsjson11_deserializeDocumentTooManyTagsException(v **types.TooManyTagsException, value interface{}) error { 11674 if v == nil { 11675 return fmt.Errorf("unexpected nil of type %T", v) 11676 } 11677 if value == nil { 11678 return nil 11679 } 11680 11681 shape, ok := value.(map[string]interface{}) 11682 if !ok { 11683 return fmt.Errorf("unexpected JSON type %v", value) 11684 } 11685 11686 var sv *types.TooManyTagsException 11687 if *v == nil { 11688 sv = &types.TooManyTagsException{} 11689 } else { 11690 sv = *v 11691 } 11692 11693 for key, value := range shape { 11694 switch key { 11695 case "message": 11696 if value != nil { 11697 jtv, ok := value.(string) 11698 if !ok { 11699 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 11700 } 11701 sv.Message = ptr.String(jtv) 11702 } 11703 11704 default: 11705 _, _ = key, value 11706 11707 } 11708 } 11709 *v = sv 11710 return nil 11711} 11712 11713func awsAwsjson11_deserializeDocumentTransitionState(v **types.TransitionState, value interface{}) error { 11714 if v == nil { 11715 return fmt.Errorf("unexpected nil of type %T", v) 11716 } 11717 if value == nil { 11718 return nil 11719 } 11720 11721 shape, ok := value.(map[string]interface{}) 11722 if !ok { 11723 return fmt.Errorf("unexpected JSON type %v", value) 11724 } 11725 11726 var sv *types.TransitionState 11727 if *v == nil { 11728 sv = &types.TransitionState{} 11729 } else { 11730 sv = *v 11731 } 11732 11733 for key, value := range shape { 11734 switch key { 11735 case "disabledReason": 11736 if value != nil { 11737 jtv, ok := value.(string) 11738 if !ok { 11739 return fmt.Errorf("expected DisabledReason to be of type string, got %T instead", value) 11740 } 11741 sv.DisabledReason = ptr.String(jtv) 11742 } 11743 11744 case "enabled": 11745 if value != nil { 11746 jtv, ok := value.(bool) 11747 if !ok { 11748 return fmt.Errorf("expected Enabled to be of type *bool, got %T instead", value) 11749 } 11750 sv.Enabled = jtv 11751 } 11752 11753 case "lastChangedAt": 11754 if value != nil { 11755 switch jtv := value.(type) { 11756 case json.Number: 11757 f64, err := jtv.Float64() 11758 if err != nil { 11759 return err 11760 } 11761 sv.LastChangedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 11762 11763 default: 11764 return fmt.Errorf("expected LastChangedAt to be a JSON Number, got %T instead", value) 11765 11766 } 11767 } 11768 11769 case "lastChangedBy": 11770 if value != nil { 11771 jtv, ok := value.(string) 11772 if !ok { 11773 return fmt.Errorf("expected LastChangedBy to be of type string, got %T instead", value) 11774 } 11775 sv.LastChangedBy = ptr.String(jtv) 11776 } 11777 11778 default: 11779 _, _ = key, value 11780 11781 } 11782 } 11783 *v = sv 11784 return nil 11785} 11786 11787func awsAwsjson11_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error { 11788 if v == nil { 11789 return fmt.Errorf("unexpected nil of type %T", v) 11790 } 11791 if value == nil { 11792 return nil 11793 } 11794 11795 shape, ok := value.(map[string]interface{}) 11796 if !ok { 11797 return fmt.Errorf("unexpected JSON type %v", value) 11798 } 11799 11800 var sv *types.ValidationException 11801 if *v == nil { 11802 sv = &types.ValidationException{} 11803 } else { 11804 sv = *v 11805 } 11806 11807 for key, value := range shape { 11808 switch key { 11809 case "message": 11810 if value != nil { 11811 jtv, ok := value.(string) 11812 if !ok { 11813 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 11814 } 11815 sv.Message = ptr.String(jtv) 11816 } 11817 11818 default: 11819 _, _ = key, value 11820 11821 } 11822 } 11823 *v = sv 11824 return nil 11825} 11826 11827func awsAwsjson11_deserializeDocumentWebhookAuthConfiguration(v **types.WebhookAuthConfiguration, value interface{}) error { 11828 if v == nil { 11829 return fmt.Errorf("unexpected nil of type %T", v) 11830 } 11831 if value == nil { 11832 return nil 11833 } 11834 11835 shape, ok := value.(map[string]interface{}) 11836 if !ok { 11837 return fmt.Errorf("unexpected JSON type %v", value) 11838 } 11839 11840 var sv *types.WebhookAuthConfiguration 11841 if *v == nil { 11842 sv = &types.WebhookAuthConfiguration{} 11843 } else { 11844 sv = *v 11845 } 11846 11847 for key, value := range shape { 11848 switch key { 11849 case "AllowedIPRange": 11850 if value != nil { 11851 jtv, ok := value.(string) 11852 if !ok { 11853 return fmt.Errorf("expected WebhookAuthConfigurationAllowedIPRange to be of type string, got %T instead", value) 11854 } 11855 sv.AllowedIPRange = ptr.String(jtv) 11856 } 11857 11858 case "SecretToken": 11859 if value != nil { 11860 jtv, ok := value.(string) 11861 if !ok { 11862 return fmt.Errorf("expected WebhookAuthConfigurationSecretToken to be of type string, got %T instead", value) 11863 } 11864 sv.SecretToken = ptr.String(jtv) 11865 } 11866 11867 default: 11868 _, _ = key, value 11869 11870 } 11871 } 11872 *v = sv 11873 return nil 11874} 11875 11876func awsAwsjson11_deserializeDocumentWebhookDefinition(v **types.WebhookDefinition, value interface{}) error { 11877 if v == nil { 11878 return fmt.Errorf("unexpected nil of type %T", v) 11879 } 11880 if value == nil { 11881 return nil 11882 } 11883 11884 shape, ok := value.(map[string]interface{}) 11885 if !ok { 11886 return fmt.Errorf("unexpected JSON type %v", value) 11887 } 11888 11889 var sv *types.WebhookDefinition 11890 if *v == nil { 11891 sv = &types.WebhookDefinition{} 11892 } else { 11893 sv = *v 11894 } 11895 11896 for key, value := range shape { 11897 switch key { 11898 case "authentication": 11899 if value != nil { 11900 jtv, ok := value.(string) 11901 if !ok { 11902 return fmt.Errorf("expected WebhookAuthenticationType to be of type string, got %T instead", value) 11903 } 11904 sv.Authentication = types.WebhookAuthenticationType(jtv) 11905 } 11906 11907 case "authenticationConfiguration": 11908 if err := awsAwsjson11_deserializeDocumentWebhookAuthConfiguration(&sv.AuthenticationConfiguration, value); err != nil { 11909 return err 11910 } 11911 11912 case "filters": 11913 if err := awsAwsjson11_deserializeDocumentWebhookFilters(&sv.Filters, value); err != nil { 11914 return err 11915 } 11916 11917 case "name": 11918 if value != nil { 11919 jtv, ok := value.(string) 11920 if !ok { 11921 return fmt.Errorf("expected WebhookName to be of type string, got %T instead", value) 11922 } 11923 sv.Name = ptr.String(jtv) 11924 } 11925 11926 case "targetAction": 11927 if value != nil { 11928 jtv, ok := value.(string) 11929 if !ok { 11930 return fmt.Errorf("expected ActionName to be of type string, got %T instead", value) 11931 } 11932 sv.TargetAction = ptr.String(jtv) 11933 } 11934 11935 case "targetPipeline": 11936 if value != nil { 11937 jtv, ok := value.(string) 11938 if !ok { 11939 return fmt.Errorf("expected PipelineName to be of type string, got %T instead", value) 11940 } 11941 sv.TargetPipeline = ptr.String(jtv) 11942 } 11943 11944 default: 11945 _, _ = key, value 11946 11947 } 11948 } 11949 *v = sv 11950 return nil 11951} 11952 11953func awsAwsjson11_deserializeDocumentWebhookFilterRule(v **types.WebhookFilterRule, value interface{}) error { 11954 if v == nil { 11955 return fmt.Errorf("unexpected nil of type %T", v) 11956 } 11957 if value == nil { 11958 return nil 11959 } 11960 11961 shape, ok := value.(map[string]interface{}) 11962 if !ok { 11963 return fmt.Errorf("unexpected JSON type %v", value) 11964 } 11965 11966 var sv *types.WebhookFilterRule 11967 if *v == nil { 11968 sv = &types.WebhookFilterRule{} 11969 } else { 11970 sv = *v 11971 } 11972 11973 for key, value := range shape { 11974 switch key { 11975 case "jsonPath": 11976 if value != nil { 11977 jtv, ok := value.(string) 11978 if !ok { 11979 return fmt.Errorf("expected JsonPath to be of type string, got %T instead", value) 11980 } 11981 sv.JsonPath = ptr.String(jtv) 11982 } 11983 11984 case "matchEquals": 11985 if value != nil { 11986 jtv, ok := value.(string) 11987 if !ok { 11988 return fmt.Errorf("expected MatchEquals to be of type string, got %T instead", value) 11989 } 11990 sv.MatchEquals = ptr.String(jtv) 11991 } 11992 11993 default: 11994 _, _ = key, value 11995 11996 } 11997 } 11998 *v = sv 11999 return nil 12000} 12001 12002func awsAwsjson11_deserializeDocumentWebhookFilters(v *[]types.WebhookFilterRule, value interface{}) error { 12003 if v == nil { 12004 return fmt.Errorf("unexpected nil of type %T", v) 12005 } 12006 if value == nil { 12007 return nil 12008 } 12009 12010 shape, ok := value.([]interface{}) 12011 if !ok { 12012 return fmt.Errorf("unexpected JSON type %v", value) 12013 } 12014 12015 var cv []types.WebhookFilterRule 12016 if *v == nil { 12017 cv = []types.WebhookFilterRule{} 12018 } else { 12019 cv = *v 12020 } 12021 12022 for _, value := range shape { 12023 var col types.WebhookFilterRule 12024 destAddr := &col 12025 if err := awsAwsjson11_deserializeDocumentWebhookFilterRule(&destAddr, value); err != nil { 12026 return err 12027 } 12028 col = *destAddr 12029 cv = append(cv, col) 12030 12031 } 12032 *v = cv 12033 return nil 12034} 12035 12036func awsAwsjson11_deserializeDocumentWebhookList(v *[]types.ListWebhookItem, value interface{}) error { 12037 if v == nil { 12038 return fmt.Errorf("unexpected nil of type %T", v) 12039 } 12040 if value == nil { 12041 return nil 12042 } 12043 12044 shape, ok := value.([]interface{}) 12045 if !ok { 12046 return fmt.Errorf("unexpected JSON type %v", value) 12047 } 12048 12049 var cv []types.ListWebhookItem 12050 if *v == nil { 12051 cv = []types.ListWebhookItem{} 12052 } else { 12053 cv = *v 12054 } 12055 12056 for _, value := range shape { 12057 var col types.ListWebhookItem 12058 destAddr := &col 12059 if err := awsAwsjson11_deserializeDocumentListWebhookItem(&destAddr, value); err != nil { 12060 return err 12061 } 12062 col = *destAddr 12063 cv = append(cv, col) 12064 12065 } 12066 *v = cv 12067 return nil 12068} 12069 12070func awsAwsjson11_deserializeDocumentWebhookNotFoundException(v **types.WebhookNotFoundException, value interface{}) error { 12071 if v == nil { 12072 return fmt.Errorf("unexpected nil of type %T", v) 12073 } 12074 if value == nil { 12075 return nil 12076 } 12077 12078 shape, ok := value.(map[string]interface{}) 12079 if !ok { 12080 return fmt.Errorf("unexpected JSON type %v", value) 12081 } 12082 12083 var sv *types.WebhookNotFoundException 12084 if *v == nil { 12085 sv = &types.WebhookNotFoundException{} 12086 } else { 12087 sv = *v 12088 } 12089 12090 for key, value := range shape { 12091 switch key { 12092 default: 12093 _, _ = key, value 12094 12095 } 12096 } 12097 *v = sv 12098 return nil 12099} 12100 12101func awsAwsjson11_deserializeOpDocumentAcknowledgeJobOutput(v **AcknowledgeJobOutput, value interface{}) error { 12102 if v == nil { 12103 return fmt.Errorf("unexpected nil of type %T", v) 12104 } 12105 if value == nil { 12106 return nil 12107 } 12108 12109 shape, ok := value.(map[string]interface{}) 12110 if !ok { 12111 return fmt.Errorf("unexpected JSON type %v", value) 12112 } 12113 12114 var sv *AcknowledgeJobOutput 12115 if *v == nil { 12116 sv = &AcknowledgeJobOutput{} 12117 } else { 12118 sv = *v 12119 } 12120 12121 for key, value := range shape { 12122 switch key { 12123 case "status": 12124 if value != nil { 12125 jtv, ok := value.(string) 12126 if !ok { 12127 return fmt.Errorf("expected JobStatus to be of type string, got %T instead", value) 12128 } 12129 sv.Status = types.JobStatus(jtv) 12130 } 12131 12132 default: 12133 _, _ = key, value 12134 12135 } 12136 } 12137 *v = sv 12138 return nil 12139} 12140 12141func awsAwsjson11_deserializeOpDocumentAcknowledgeThirdPartyJobOutput(v **AcknowledgeThirdPartyJobOutput, value interface{}) error { 12142 if v == nil { 12143 return fmt.Errorf("unexpected nil of type %T", v) 12144 } 12145 if value == nil { 12146 return nil 12147 } 12148 12149 shape, ok := value.(map[string]interface{}) 12150 if !ok { 12151 return fmt.Errorf("unexpected JSON type %v", value) 12152 } 12153 12154 var sv *AcknowledgeThirdPartyJobOutput 12155 if *v == nil { 12156 sv = &AcknowledgeThirdPartyJobOutput{} 12157 } else { 12158 sv = *v 12159 } 12160 12161 for key, value := range shape { 12162 switch key { 12163 case "status": 12164 if value != nil { 12165 jtv, ok := value.(string) 12166 if !ok { 12167 return fmt.Errorf("expected JobStatus to be of type string, got %T instead", value) 12168 } 12169 sv.Status = types.JobStatus(jtv) 12170 } 12171 12172 default: 12173 _, _ = key, value 12174 12175 } 12176 } 12177 *v = sv 12178 return nil 12179} 12180 12181func awsAwsjson11_deserializeOpDocumentCreateCustomActionTypeOutput(v **CreateCustomActionTypeOutput, value interface{}) error { 12182 if v == nil { 12183 return fmt.Errorf("unexpected nil of type %T", v) 12184 } 12185 if value == nil { 12186 return nil 12187 } 12188 12189 shape, ok := value.(map[string]interface{}) 12190 if !ok { 12191 return fmt.Errorf("unexpected JSON type %v", value) 12192 } 12193 12194 var sv *CreateCustomActionTypeOutput 12195 if *v == nil { 12196 sv = &CreateCustomActionTypeOutput{} 12197 } else { 12198 sv = *v 12199 } 12200 12201 for key, value := range shape { 12202 switch key { 12203 case "actionType": 12204 if err := awsAwsjson11_deserializeDocumentActionType(&sv.ActionType, value); err != nil { 12205 return err 12206 } 12207 12208 case "tags": 12209 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil { 12210 return err 12211 } 12212 12213 default: 12214 _, _ = key, value 12215 12216 } 12217 } 12218 *v = sv 12219 return nil 12220} 12221 12222func awsAwsjson11_deserializeOpDocumentCreatePipelineOutput(v **CreatePipelineOutput, value interface{}) error { 12223 if v == nil { 12224 return fmt.Errorf("unexpected nil of type %T", v) 12225 } 12226 if value == nil { 12227 return nil 12228 } 12229 12230 shape, ok := value.(map[string]interface{}) 12231 if !ok { 12232 return fmt.Errorf("unexpected JSON type %v", value) 12233 } 12234 12235 var sv *CreatePipelineOutput 12236 if *v == nil { 12237 sv = &CreatePipelineOutput{} 12238 } else { 12239 sv = *v 12240 } 12241 12242 for key, value := range shape { 12243 switch key { 12244 case "pipeline": 12245 if err := awsAwsjson11_deserializeDocumentPipelineDeclaration(&sv.Pipeline, value); err != nil { 12246 return err 12247 } 12248 12249 case "tags": 12250 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil { 12251 return err 12252 } 12253 12254 default: 12255 _, _ = key, value 12256 12257 } 12258 } 12259 *v = sv 12260 return nil 12261} 12262 12263func awsAwsjson11_deserializeOpDocumentDeleteWebhookOutput(v **DeleteWebhookOutput, value interface{}) error { 12264 if v == nil { 12265 return fmt.Errorf("unexpected nil of type %T", v) 12266 } 12267 if value == nil { 12268 return nil 12269 } 12270 12271 shape, ok := value.(map[string]interface{}) 12272 if !ok { 12273 return fmt.Errorf("unexpected JSON type %v", value) 12274 } 12275 12276 var sv *DeleteWebhookOutput 12277 if *v == nil { 12278 sv = &DeleteWebhookOutput{} 12279 } else { 12280 sv = *v 12281 } 12282 12283 for key, value := range shape { 12284 switch key { 12285 default: 12286 _, _ = key, value 12287 12288 } 12289 } 12290 *v = sv 12291 return nil 12292} 12293 12294func awsAwsjson11_deserializeOpDocumentDeregisterWebhookWithThirdPartyOutput(v **DeregisterWebhookWithThirdPartyOutput, value interface{}) error { 12295 if v == nil { 12296 return fmt.Errorf("unexpected nil of type %T", v) 12297 } 12298 if value == nil { 12299 return nil 12300 } 12301 12302 shape, ok := value.(map[string]interface{}) 12303 if !ok { 12304 return fmt.Errorf("unexpected JSON type %v", value) 12305 } 12306 12307 var sv *DeregisterWebhookWithThirdPartyOutput 12308 if *v == nil { 12309 sv = &DeregisterWebhookWithThirdPartyOutput{} 12310 } else { 12311 sv = *v 12312 } 12313 12314 for key, value := range shape { 12315 switch key { 12316 default: 12317 _, _ = key, value 12318 12319 } 12320 } 12321 *v = sv 12322 return nil 12323} 12324 12325func awsAwsjson11_deserializeOpDocumentGetActionTypeOutput(v **GetActionTypeOutput, value interface{}) error { 12326 if v == nil { 12327 return fmt.Errorf("unexpected nil of type %T", v) 12328 } 12329 if value == nil { 12330 return nil 12331 } 12332 12333 shape, ok := value.(map[string]interface{}) 12334 if !ok { 12335 return fmt.Errorf("unexpected JSON type %v", value) 12336 } 12337 12338 var sv *GetActionTypeOutput 12339 if *v == nil { 12340 sv = &GetActionTypeOutput{} 12341 } else { 12342 sv = *v 12343 } 12344 12345 for key, value := range shape { 12346 switch key { 12347 case "actionType": 12348 if err := awsAwsjson11_deserializeDocumentActionTypeDeclaration(&sv.ActionType, value); err != nil { 12349 return err 12350 } 12351 12352 default: 12353 _, _ = key, value 12354 12355 } 12356 } 12357 *v = sv 12358 return nil 12359} 12360 12361func awsAwsjson11_deserializeOpDocumentGetJobDetailsOutput(v **GetJobDetailsOutput, value interface{}) error { 12362 if v == nil { 12363 return fmt.Errorf("unexpected nil of type %T", v) 12364 } 12365 if value == nil { 12366 return nil 12367 } 12368 12369 shape, ok := value.(map[string]interface{}) 12370 if !ok { 12371 return fmt.Errorf("unexpected JSON type %v", value) 12372 } 12373 12374 var sv *GetJobDetailsOutput 12375 if *v == nil { 12376 sv = &GetJobDetailsOutput{} 12377 } else { 12378 sv = *v 12379 } 12380 12381 for key, value := range shape { 12382 switch key { 12383 case "jobDetails": 12384 if err := awsAwsjson11_deserializeDocumentJobDetails(&sv.JobDetails, value); err != nil { 12385 return err 12386 } 12387 12388 default: 12389 _, _ = key, value 12390 12391 } 12392 } 12393 *v = sv 12394 return nil 12395} 12396 12397func awsAwsjson11_deserializeOpDocumentGetPipelineExecutionOutput(v **GetPipelineExecutionOutput, value interface{}) error { 12398 if v == nil { 12399 return fmt.Errorf("unexpected nil of type %T", v) 12400 } 12401 if value == nil { 12402 return nil 12403 } 12404 12405 shape, ok := value.(map[string]interface{}) 12406 if !ok { 12407 return fmt.Errorf("unexpected JSON type %v", value) 12408 } 12409 12410 var sv *GetPipelineExecutionOutput 12411 if *v == nil { 12412 sv = &GetPipelineExecutionOutput{} 12413 } else { 12414 sv = *v 12415 } 12416 12417 for key, value := range shape { 12418 switch key { 12419 case "pipelineExecution": 12420 if err := awsAwsjson11_deserializeDocumentPipelineExecution(&sv.PipelineExecution, value); err != nil { 12421 return err 12422 } 12423 12424 default: 12425 _, _ = key, value 12426 12427 } 12428 } 12429 *v = sv 12430 return nil 12431} 12432 12433func awsAwsjson11_deserializeOpDocumentGetPipelineOutput(v **GetPipelineOutput, value interface{}) error { 12434 if v == nil { 12435 return fmt.Errorf("unexpected nil of type %T", v) 12436 } 12437 if value == nil { 12438 return nil 12439 } 12440 12441 shape, ok := value.(map[string]interface{}) 12442 if !ok { 12443 return fmt.Errorf("unexpected JSON type %v", value) 12444 } 12445 12446 var sv *GetPipelineOutput 12447 if *v == nil { 12448 sv = &GetPipelineOutput{} 12449 } else { 12450 sv = *v 12451 } 12452 12453 for key, value := range shape { 12454 switch key { 12455 case "metadata": 12456 if err := awsAwsjson11_deserializeDocumentPipelineMetadata(&sv.Metadata, value); err != nil { 12457 return err 12458 } 12459 12460 case "pipeline": 12461 if err := awsAwsjson11_deserializeDocumentPipelineDeclaration(&sv.Pipeline, value); err != nil { 12462 return err 12463 } 12464 12465 default: 12466 _, _ = key, value 12467 12468 } 12469 } 12470 *v = sv 12471 return nil 12472} 12473 12474func awsAwsjson11_deserializeOpDocumentGetPipelineStateOutput(v **GetPipelineStateOutput, value interface{}) error { 12475 if v == nil { 12476 return fmt.Errorf("unexpected nil of type %T", v) 12477 } 12478 if value == nil { 12479 return nil 12480 } 12481 12482 shape, ok := value.(map[string]interface{}) 12483 if !ok { 12484 return fmt.Errorf("unexpected JSON type %v", value) 12485 } 12486 12487 var sv *GetPipelineStateOutput 12488 if *v == nil { 12489 sv = &GetPipelineStateOutput{} 12490 } else { 12491 sv = *v 12492 } 12493 12494 for key, value := range shape { 12495 switch key { 12496 case "created": 12497 if value != nil { 12498 switch jtv := value.(type) { 12499 case json.Number: 12500 f64, err := jtv.Float64() 12501 if err != nil { 12502 return err 12503 } 12504 sv.Created = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12505 12506 default: 12507 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 12508 12509 } 12510 } 12511 12512 case "pipelineName": 12513 if value != nil { 12514 jtv, ok := value.(string) 12515 if !ok { 12516 return fmt.Errorf("expected PipelineName to be of type string, got %T instead", value) 12517 } 12518 sv.PipelineName = ptr.String(jtv) 12519 } 12520 12521 case "pipelineVersion": 12522 if value != nil { 12523 jtv, ok := value.(json.Number) 12524 if !ok { 12525 return fmt.Errorf("expected PipelineVersion to be json.Number, got %T instead", value) 12526 } 12527 i64, err := jtv.Int64() 12528 if err != nil { 12529 return err 12530 } 12531 sv.PipelineVersion = ptr.Int32(int32(i64)) 12532 } 12533 12534 case "stageStates": 12535 if err := awsAwsjson11_deserializeDocumentStageStateList(&sv.StageStates, value); err != nil { 12536 return err 12537 } 12538 12539 case "updated": 12540 if value != nil { 12541 switch jtv := value.(type) { 12542 case json.Number: 12543 f64, err := jtv.Float64() 12544 if err != nil { 12545 return err 12546 } 12547 sv.Updated = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12548 12549 default: 12550 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 12551 12552 } 12553 } 12554 12555 default: 12556 _, _ = key, value 12557 12558 } 12559 } 12560 *v = sv 12561 return nil 12562} 12563 12564func awsAwsjson11_deserializeOpDocumentGetThirdPartyJobDetailsOutput(v **GetThirdPartyJobDetailsOutput, value interface{}) error { 12565 if v == nil { 12566 return fmt.Errorf("unexpected nil of type %T", v) 12567 } 12568 if value == nil { 12569 return nil 12570 } 12571 12572 shape, ok := value.(map[string]interface{}) 12573 if !ok { 12574 return fmt.Errorf("unexpected JSON type %v", value) 12575 } 12576 12577 var sv *GetThirdPartyJobDetailsOutput 12578 if *v == nil { 12579 sv = &GetThirdPartyJobDetailsOutput{} 12580 } else { 12581 sv = *v 12582 } 12583 12584 for key, value := range shape { 12585 switch key { 12586 case "jobDetails": 12587 if err := awsAwsjson11_deserializeDocumentThirdPartyJobDetails(&sv.JobDetails, value); err != nil { 12588 return err 12589 } 12590 12591 default: 12592 _, _ = key, value 12593 12594 } 12595 } 12596 *v = sv 12597 return nil 12598} 12599 12600func awsAwsjson11_deserializeOpDocumentListActionExecutionsOutput(v **ListActionExecutionsOutput, value interface{}) error { 12601 if v == nil { 12602 return fmt.Errorf("unexpected nil of type %T", v) 12603 } 12604 if value == nil { 12605 return nil 12606 } 12607 12608 shape, ok := value.(map[string]interface{}) 12609 if !ok { 12610 return fmt.Errorf("unexpected JSON type %v", value) 12611 } 12612 12613 var sv *ListActionExecutionsOutput 12614 if *v == nil { 12615 sv = &ListActionExecutionsOutput{} 12616 } else { 12617 sv = *v 12618 } 12619 12620 for key, value := range shape { 12621 switch key { 12622 case "actionExecutionDetails": 12623 if err := awsAwsjson11_deserializeDocumentActionExecutionDetailList(&sv.ActionExecutionDetails, value); err != nil { 12624 return err 12625 } 12626 12627 case "nextToken": 12628 if value != nil { 12629 jtv, ok := value.(string) 12630 if !ok { 12631 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12632 } 12633 sv.NextToken = ptr.String(jtv) 12634 } 12635 12636 default: 12637 _, _ = key, value 12638 12639 } 12640 } 12641 *v = sv 12642 return nil 12643} 12644 12645func awsAwsjson11_deserializeOpDocumentListActionTypesOutput(v **ListActionTypesOutput, value interface{}) error { 12646 if v == nil { 12647 return fmt.Errorf("unexpected nil of type %T", v) 12648 } 12649 if value == nil { 12650 return nil 12651 } 12652 12653 shape, ok := value.(map[string]interface{}) 12654 if !ok { 12655 return fmt.Errorf("unexpected JSON type %v", value) 12656 } 12657 12658 var sv *ListActionTypesOutput 12659 if *v == nil { 12660 sv = &ListActionTypesOutput{} 12661 } else { 12662 sv = *v 12663 } 12664 12665 for key, value := range shape { 12666 switch key { 12667 case "actionTypes": 12668 if err := awsAwsjson11_deserializeDocumentActionTypeList(&sv.ActionTypes, value); err != nil { 12669 return err 12670 } 12671 12672 case "nextToken": 12673 if value != nil { 12674 jtv, ok := value.(string) 12675 if !ok { 12676 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12677 } 12678 sv.NextToken = ptr.String(jtv) 12679 } 12680 12681 default: 12682 _, _ = key, value 12683 12684 } 12685 } 12686 *v = sv 12687 return nil 12688} 12689 12690func awsAwsjson11_deserializeOpDocumentListPipelineExecutionsOutput(v **ListPipelineExecutionsOutput, value interface{}) error { 12691 if v == nil { 12692 return fmt.Errorf("unexpected nil of type %T", v) 12693 } 12694 if value == nil { 12695 return nil 12696 } 12697 12698 shape, ok := value.(map[string]interface{}) 12699 if !ok { 12700 return fmt.Errorf("unexpected JSON type %v", value) 12701 } 12702 12703 var sv *ListPipelineExecutionsOutput 12704 if *v == nil { 12705 sv = &ListPipelineExecutionsOutput{} 12706 } else { 12707 sv = *v 12708 } 12709 12710 for key, value := range shape { 12711 switch key { 12712 case "nextToken": 12713 if value != nil { 12714 jtv, ok := value.(string) 12715 if !ok { 12716 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12717 } 12718 sv.NextToken = ptr.String(jtv) 12719 } 12720 12721 case "pipelineExecutionSummaries": 12722 if err := awsAwsjson11_deserializeDocumentPipelineExecutionSummaryList(&sv.PipelineExecutionSummaries, value); err != nil { 12723 return err 12724 } 12725 12726 default: 12727 _, _ = key, value 12728 12729 } 12730 } 12731 *v = sv 12732 return nil 12733} 12734 12735func awsAwsjson11_deserializeOpDocumentListPipelinesOutput(v **ListPipelinesOutput, value interface{}) error { 12736 if v == nil { 12737 return fmt.Errorf("unexpected nil of type %T", v) 12738 } 12739 if value == nil { 12740 return nil 12741 } 12742 12743 shape, ok := value.(map[string]interface{}) 12744 if !ok { 12745 return fmt.Errorf("unexpected JSON type %v", value) 12746 } 12747 12748 var sv *ListPipelinesOutput 12749 if *v == nil { 12750 sv = &ListPipelinesOutput{} 12751 } else { 12752 sv = *v 12753 } 12754 12755 for key, value := range shape { 12756 switch key { 12757 case "nextToken": 12758 if value != nil { 12759 jtv, ok := value.(string) 12760 if !ok { 12761 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12762 } 12763 sv.NextToken = ptr.String(jtv) 12764 } 12765 12766 case "pipelines": 12767 if err := awsAwsjson11_deserializeDocumentPipelineList(&sv.Pipelines, value); err != nil { 12768 return err 12769 } 12770 12771 default: 12772 _, _ = key, value 12773 12774 } 12775 } 12776 *v = sv 12777 return nil 12778} 12779 12780func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 12781 if v == nil { 12782 return fmt.Errorf("unexpected nil of type %T", v) 12783 } 12784 if value == nil { 12785 return nil 12786 } 12787 12788 shape, ok := value.(map[string]interface{}) 12789 if !ok { 12790 return fmt.Errorf("unexpected JSON type %v", value) 12791 } 12792 12793 var sv *ListTagsForResourceOutput 12794 if *v == nil { 12795 sv = &ListTagsForResourceOutput{} 12796 } else { 12797 sv = *v 12798 } 12799 12800 for key, value := range shape { 12801 switch key { 12802 case "nextToken": 12803 if value != nil { 12804 jtv, ok := value.(string) 12805 if !ok { 12806 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12807 } 12808 sv.NextToken = ptr.String(jtv) 12809 } 12810 12811 case "tags": 12812 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil { 12813 return err 12814 } 12815 12816 default: 12817 _, _ = key, value 12818 12819 } 12820 } 12821 *v = sv 12822 return nil 12823} 12824 12825func awsAwsjson11_deserializeOpDocumentListWebhooksOutput(v **ListWebhooksOutput, value interface{}) error { 12826 if v == nil { 12827 return fmt.Errorf("unexpected nil of type %T", v) 12828 } 12829 if value == nil { 12830 return nil 12831 } 12832 12833 shape, ok := value.(map[string]interface{}) 12834 if !ok { 12835 return fmt.Errorf("unexpected JSON type %v", value) 12836 } 12837 12838 var sv *ListWebhooksOutput 12839 if *v == nil { 12840 sv = &ListWebhooksOutput{} 12841 } else { 12842 sv = *v 12843 } 12844 12845 for key, value := range shape { 12846 switch key { 12847 case "NextToken": 12848 if value != nil { 12849 jtv, ok := value.(string) 12850 if !ok { 12851 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12852 } 12853 sv.NextToken = ptr.String(jtv) 12854 } 12855 12856 case "webhooks": 12857 if err := awsAwsjson11_deserializeDocumentWebhookList(&sv.Webhooks, value); err != nil { 12858 return err 12859 } 12860 12861 default: 12862 _, _ = key, value 12863 12864 } 12865 } 12866 *v = sv 12867 return nil 12868} 12869 12870func awsAwsjson11_deserializeOpDocumentPollForJobsOutput(v **PollForJobsOutput, value interface{}) error { 12871 if v == nil { 12872 return fmt.Errorf("unexpected nil of type %T", v) 12873 } 12874 if value == nil { 12875 return nil 12876 } 12877 12878 shape, ok := value.(map[string]interface{}) 12879 if !ok { 12880 return fmt.Errorf("unexpected JSON type %v", value) 12881 } 12882 12883 var sv *PollForJobsOutput 12884 if *v == nil { 12885 sv = &PollForJobsOutput{} 12886 } else { 12887 sv = *v 12888 } 12889 12890 for key, value := range shape { 12891 switch key { 12892 case "jobs": 12893 if err := awsAwsjson11_deserializeDocumentJobList(&sv.Jobs, value); err != nil { 12894 return err 12895 } 12896 12897 default: 12898 _, _ = key, value 12899 12900 } 12901 } 12902 *v = sv 12903 return nil 12904} 12905 12906func awsAwsjson11_deserializeOpDocumentPollForThirdPartyJobsOutput(v **PollForThirdPartyJobsOutput, value interface{}) error { 12907 if v == nil { 12908 return fmt.Errorf("unexpected nil of type %T", v) 12909 } 12910 if value == nil { 12911 return nil 12912 } 12913 12914 shape, ok := value.(map[string]interface{}) 12915 if !ok { 12916 return fmt.Errorf("unexpected JSON type %v", value) 12917 } 12918 12919 var sv *PollForThirdPartyJobsOutput 12920 if *v == nil { 12921 sv = &PollForThirdPartyJobsOutput{} 12922 } else { 12923 sv = *v 12924 } 12925 12926 for key, value := range shape { 12927 switch key { 12928 case "jobs": 12929 if err := awsAwsjson11_deserializeDocumentThirdPartyJobList(&sv.Jobs, value); err != nil { 12930 return err 12931 } 12932 12933 default: 12934 _, _ = key, value 12935 12936 } 12937 } 12938 *v = sv 12939 return nil 12940} 12941 12942func awsAwsjson11_deserializeOpDocumentPutActionRevisionOutput(v **PutActionRevisionOutput, value interface{}) error { 12943 if v == nil { 12944 return fmt.Errorf("unexpected nil of type %T", v) 12945 } 12946 if value == nil { 12947 return nil 12948 } 12949 12950 shape, ok := value.(map[string]interface{}) 12951 if !ok { 12952 return fmt.Errorf("unexpected JSON type %v", value) 12953 } 12954 12955 var sv *PutActionRevisionOutput 12956 if *v == nil { 12957 sv = &PutActionRevisionOutput{} 12958 } else { 12959 sv = *v 12960 } 12961 12962 for key, value := range shape { 12963 switch key { 12964 case "newRevision": 12965 if value != nil { 12966 jtv, ok := value.(bool) 12967 if !ok { 12968 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 12969 } 12970 sv.NewRevision = jtv 12971 } 12972 12973 case "pipelineExecutionId": 12974 if value != nil { 12975 jtv, ok := value.(string) 12976 if !ok { 12977 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 12978 } 12979 sv.PipelineExecutionId = ptr.String(jtv) 12980 } 12981 12982 default: 12983 _, _ = key, value 12984 12985 } 12986 } 12987 *v = sv 12988 return nil 12989} 12990 12991func awsAwsjson11_deserializeOpDocumentPutApprovalResultOutput(v **PutApprovalResultOutput, value interface{}) error { 12992 if v == nil { 12993 return fmt.Errorf("unexpected nil of type %T", v) 12994 } 12995 if value == nil { 12996 return nil 12997 } 12998 12999 shape, ok := value.(map[string]interface{}) 13000 if !ok { 13001 return fmt.Errorf("unexpected JSON type %v", value) 13002 } 13003 13004 var sv *PutApprovalResultOutput 13005 if *v == nil { 13006 sv = &PutApprovalResultOutput{} 13007 } else { 13008 sv = *v 13009 } 13010 13011 for key, value := range shape { 13012 switch key { 13013 case "approvedAt": 13014 if value != nil { 13015 switch jtv := value.(type) { 13016 case json.Number: 13017 f64, err := jtv.Float64() 13018 if err != nil { 13019 return err 13020 } 13021 sv.ApprovedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13022 13023 default: 13024 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 13025 13026 } 13027 } 13028 13029 default: 13030 _, _ = key, value 13031 13032 } 13033 } 13034 *v = sv 13035 return nil 13036} 13037 13038func awsAwsjson11_deserializeOpDocumentPutWebhookOutput(v **PutWebhookOutput, value interface{}) error { 13039 if v == nil { 13040 return fmt.Errorf("unexpected nil of type %T", v) 13041 } 13042 if value == nil { 13043 return nil 13044 } 13045 13046 shape, ok := value.(map[string]interface{}) 13047 if !ok { 13048 return fmt.Errorf("unexpected JSON type %v", value) 13049 } 13050 13051 var sv *PutWebhookOutput 13052 if *v == nil { 13053 sv = &PutWebhookOutput{} 13054 } else { 13055 sv = *v 13056 } 13057 13058 for key, value := range shape { 13059 switch key { 13060 case "webhook": 13061 if err := awsAwsjson11_deserializeDocumentListWebhookItem(&sv.Webhook, value); err != nil { 13062 return err 13063 } 13064 13065 default: 13066 _, _ = key, value 13067 13068 } 13069 } 13070 *v = sv 13071 return nil 13072} 13073 13074func awsAwsjson11_deserializeOpDocumentRegisterWebhookWithThirdPartyOutput(v **RegisterWebhookWithThirdPartyOutput, value interface{}) error { 13075 if v == nil { 13076 return fmt.Errorf("unexpected nil of type %T", v) 13077 } 13078 if value == nil { 13079 return nil 13080 } 13081 13082 shape, ok := value.(map[string]interface{}) 13083 if !ok { 13084 return fmt.Errorf("unexpected JSON type %v", value) 13085 } 13086 13087 var sv *RegisterWebhookWithThirdPartyOutput 13088 if *v == nil { 13089 sv = &RegisterWebhookWithThirdPartyOutput{} 13090 } else { 13091 sv = *v 13092 } 13093 13094 for key, value := range shape { 13095 switch key { 13096 default: 13097 _, _ = key, value 13098 13099 } 13100 } 13101 *v = sv 13102 return nil 13103} 13104 13105func awsAwsjson11_deserializeOpDocumentRetryStageExecutionOutput(v **RetryStageExecutionOutput, value interface{}) error { 13106 if v == nil { 13107 return fmt.Errorf("unexpected nil of type %T", v) 13108 } 13109 if value == nil { 13110 return nil 13111 } 13112 13113 shape, ok := value.(map[string]interface{}) 13114 if !ok { 13115 return fmt.Errorf("unexpected JSON type %v", value) 13116 } 13117 13118 var sv *RetryStageExecutionOutput 13119 if *v == nil { 13120 sv = &RetryStageExecutionOutput{} 13121 } else { 13122 sv = *v 13123 } 13124 13125 for key, value := range shape { 13126 switch key { 13127 case "pipelineExecutionId": 13128 if value != nil { 13129 jtv, ok := value.(string) 13130 if !ok { 13131 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 13132 } 13133 sv.PipelineExecutionId = ptr.String(jtv) 13134 } 13135 13136 default: 13137 _, _ = key, value 13138 13139 } 13140 } 13141 *v = sv 13142 return nil 13143} 13144 13145func awsAwsjson11_deserializeOpDocumentStartPipelineExecutionOutput(v **StartPipelineExecutionOutput, value interface{}) error { 13146 if v == nil { 13147 return fmt.Errorf("unexpected nil of type %T", v) 13148 } 13149 if value == nil { 13150 return nil 13151 } 13152 13153 shape, ok := value.(map[string]interface{}) 13154 if !ok { 13155 return fmt.Errorf("unexpected JSON type %v", value) 13156 } 13157 13158 var sv *StartPipelineExecutionOutput 13159 if *v == nil { 13160 sv = &StartPipelineExecutionOutput{} 13161 } else { 13162 sv = *v 13163 } 13164 13165 for key, value := range shape { 13166 switch key { 13167 case "pipelineExecutionId": 13168 if value != nil { 13169 jtv, ok := value.(string) 13170 if !ok { 13171 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 13172 } 13173 sv.PipelineExecutionId = ptr.String(jtv) 13174 } 13175 13176 default: 13177 _, _ = key, value 13178 13179 } 13180 } 13181 *v = sv 13182 return nil 13183} 13184 13185func awsAwsjson11_deserializeOpDocumentStopPipelineExecutionOutput(v **StopPipelineExecutionOutput, value interface{}) error { 13186 if v == nil { 13187 return fmt.Errorf("unexpected nil of type %T", v) 13188 } 13189 if value == nil { 13190 return nil 13191 } 13192 13193 shape, ok := value.(map[string]interface{}) 13194 if !ok { 13195 return fmt.Errorf("unexpected JSON type %v", value) 13196 } 13197 13198 var sv *StopPipelineExecutionOutput 13199 if *v == nil { 13200 sv = &StopPipelineExecutionOutput{} 13201 } else { 13202 sv = *v 13203 } 13204 13205 for key, value := range shape { 13206 switch key { 13207 case "pipelineExecutionId": 13208 if value != nil { 13209 jtv, ok := value.(string) 13210 if !ok { 13211 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 13212 } 13213 sv.PipelineExecutionId = ptr.String(jtv) 13214 } 13215 13216 default: 13217 _, _ = key, value 13218 13219 } 13220 } 13221 *v = sv 13222 return nil 13223} 13224 13225func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error { 13226 if v == nil { 13227 return fmt.Errorf("unexpected nil of type %T", v) 13228 } 13229 if value == nil { 13230 return nil 13231 } 13232 13233 shape, ok := value.(map[string]interface{}) 13234 if !ok { 13235 return fmt.Errorf("unexpected JSON type %v", value) 13236 } 13237 13238 var sv *TagResourceOutput 13239 if *v == nil { 13240 sv = &TagResourceOutput{} 13241 } else { 13242 sv = *v 13243 } 13244 13245 for key, value := range shape { 13246 switch key { 13247 default: 13248 _, _ = key, value 13249 13250 } 13251 } 13252 *v = sv 13253 return nil 13254} 13255 13256func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error { 13257 if v == nil { 13258 return fmt.Errorf("unexpected nil of type %T", v) 13259 } 13260 if value == nil { 13261 return nil 13262 } 13263 13264 shape, ok := value.(map[string]interface{}) 13265 if !ok { 13266 return fmt.Errorf("unexpected JSON type %v", value) 13267 } 13268 13269 var sv *UntagResourceOutput 13270 if *v == nil { 13271 sv = &UntagResourceOutput{} 13272 } else { 13273 sv = *v 13274 } 13275 13276 for key, value := range shape { 13277 switch key { 13278 default: 13279 _, _ = key, value 13280 13281 } 13282 } 13283 *v = sv 13284 return nil 13285} 13286 13287func awsAwsjson11_deserializeOpDocumentUpdatePipelineOutput(v **UpdatePipelineOutput, value interface{}) error { 13288 if v == nil { 13289 return fmt.Errorf("unexpected nil of type %T", v) 13290 } 13291 if value == nil { 13292 return nil 13293 } 13294 13295 shape, ok := value.(map[string]interface{}) 13296 if !ok { 13297 return fmt.Errorf("unexpected JSON type %v", value) 13298 } 13299 13300 var sv *UpdatePipelineOutput 13301 if *v == nil { 13302 sv = &UpdatePipelineOutput{} 13303 } else { 13304 sv = *v 13305 } 13306 13307 for key, value := range shape { 13308 switch key { 13309 case "pipeline": 13310 if err := awsAwsjson11_deserializeDocumentPipelineDeclaration(&sv.Pipeline, value); err != nil { 13311 return err 13312 } 13313 13314 default: 13315 _, _ = key, value 13316 13317 } 13318 } 13319 *v = sv 13320 return nil 13321} 13322