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 jtv, ok := value.(json.Number) 6129 if !ok { 6130 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6131 } 6132 f64, err := jtv.Float64() 6133 if err != nil { 6134 return err 6135 } 6136 sv.LastStatusChange = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6137 } 6138 6139 case "lastUpdatedBy": 6140 if value != nil { 6141 jtv, ok := value.(string) 6142 if !ok { 6143 return fmt.Errorf("expected LastUpdatedBy to be of type string, got %T instead", value) 6144 } 6145 sv.LastUpdatedBy = ptr.String(jtv) 6146 } 6147 6148 case "percentComplete": 6149 if value != nil { 6150 jtv, ok := value.(json.Number) 6151 if !ok { 6152 return fmt.Errorf("expected Percentage to be json.Number, got %T instead", value) 6153 } 6154 i64, err := jtv.Int64() 6155 if err != nil { 6156 return err 6157 } 6158 sv.PercentComplete = ptr.Int32(int32(i64)) 6159 } 6160 6161 case "status": 6162 if value != nil { 6163 jtv, ok := value.(string) 6164 if !ok { 6165 return fmt.Errorf("expected ActionExecutionStatus to be of type string, got %T instead", value) 6166 } 6167 sv.Status = types.ActionExecutionStatus(jtv) 6168 } 6169 6170 case "summary": 6171 if value != nil { 6172 jtv, ok := value.(string) 6173 if !ok { 6174 return fmt.Errorf("expected ExecutionSummary to be of type string, got %T instead", value) 6175 } 6176 sv.Summary = ptr.String(jtv) 6177 } 6178 6179 case "token": 6180 if value != nil { 6181 jtv, ok := value.(string) 6182 if !ok { 6183 return fmt.Errorf("expected ActionExecutionToken to be of type string, got %T instead", value) 6184 } 6185 sv.Token = ptr.String(jtv) 6186 } 6187 6188 default: 6189 _, _ = key, value 6190 6191 } 6192 } 6193 *v = sv 6194 return nil 6195} 6196 6197func awsAwsjson11_deserializeDocumentActionExecutionDetail(v **types.ActionExecutionDetail, value interface{}) error { 6198 if v == nil { 6199 return fmt.Errorf("unexpected nil of type %T", v) 6200 } 6201 if value == nil { 6202 return nil 6203 } 6204 6205 shape, ok := value.(map[string]interface{}) 6206 if !ok { 6207 return fmt.Errorf("unexpected JSON type %v", value) 6208 } 6209 6210 var sv *types.ActionExecutionDetail 6211 if *v == nil { 6212 sv = &types.ActionExecutionDetail{} 6213 } else { 6214 sv = *v 6215 } 6216 6217 for key, value := range shape { 6218 switch key { 6219 case "actionExecutionId": 6220 if value != nil { 6221 jtv, ok := value.(string) 6222 if !ok { 6223 return fmt.Errorf("expected ActionExecutionId to be of type string, got %T instead", value) 6224 } 6225 sv.ActionExecutionId = ptr.String(jtv) 6226 } 6227 6228 case "actionName": 6229 if value != nil { 6230 jtv, ok := value.(string) 6231 if !ok { 6232 return fmt.Errorf("expected ActionName to be of type string, got %T instead", value) 6233 } 6234 sv.ActionName = ptr.String(jtv) 6235 } 6236 6237 case "input": 6238 if err := awsAwsjson11_deserializeDocumentActionExecutionInput(&sv.Input, value); err != nil { 6239 return err 6240 } 6241 6242 case "lastUpdateTime": 6243 if value != nil { 6244 jtv, ok := value.(json.Number) 6245 if !ok { 6246 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6247 } 6248 f64, err := jtv.Float64() 6249 if err != nil { 6250 return err 6251 } 6252 sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6253 } 6254 6255 case "output": 6256 if err := awsAwsjson11_deserializeDocumentActionExecutionOutput(&sv.Output, value); err != nil { 6257 return err 6258 } 6259 6260 case "pipelineExecutionId": 6261 if value != nil { 6262 jtv, ok := value.(string) 6263 if !ok { 6264 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 6265 } 6266 sv.PipelineExecutionId = ptr.String(jtv) 6267 } 6268 6269 case "pipelineVersion": 6270 if value != nil { 6271 jtv, ok := value.(json.Number) 6272 if !ok { 6273 return fmt.Errorf("expected PipelineVersion to be json.Number, got %T instead", value) 6274 } 6275 i64, err := jtv.Int64() 6276 if err != nil { 6277 return err 6278 } 6279 sv.PipelineVersion = ptr.Int32(int32(i64)) 6280 } 6281 6282 case "stageName": 6283 if value != nil { 6284 jtv, ok := value.(string) 6285 if !ok { 6286 return fmt.Errorf("expected StageName to be of type string, got %T instead", value) 6287 } 6288 sv.StageName = ptr.String(jtv) 6289 } 6290 6291 case "startTime": 6292 if value != nil { 6293 jtv, ok := value.(json.Number) 6294 if !ok { 6295 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6296 } 6297 f64, err := jtv.Float64() 6298 if err != nil { 6299 return err 6300 } 6301 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6302 } 6303 6304 case "status": 6305 if value != nil { 6306 jtv, ok := value.(string) 6307 if !ok { 6308 return fmt.Errorf("expected ActionExecutionStatus to be of type string, got %T instead", value) 6309 } 6310 sv.Status = types.ActionExecutionStatus(jtv) 6311 } 6312 6313 default: 6314 _, _ = key, value 6315 6316 } 6317 } 6318 *v = sv 6319 return nil 6320} 6321 6322func awsAwsjson11_deserializeDocumentActionExecutionDetailList(v *[]types.ActionExecutionDetail, value interface{}) error { 6323 if v == nil { 6324 return fmt.Errorf("unexpected nil of type %T", v) 6325 } 6326 if value == nil { 6327 return nil 6328 } 6329 6330 shape, ok := value.([]interface{}) 6331 if !ok { 6332 return fmt.Errorf("unexpected JSON type %v", value) 6333 } 6334 6335 var cv []types.ActionExecutionDetail 6336 if *v == nil { 6337 cv = []types.ActionExecutionDetail{} 6338 } else { 6339 cv = *v 6340 } 6341 6342 for _, value := range shape { 6343 var col types.ActionExecutionDetail 6344 destAddr := &col 6345 if err := awsAwsjson11_deserializeDocumentActionExecutionDetail(&destAddr, value); err != nil { 6346 return err 6347 } 6348 col = *destAddr 6349 cv = append(cv, col) 6350 6351 } 6352 *v = cv 6353 return nil 6354} 6355 6356func awsAwsjson11_deserializeDocumentActionExecutionInput(v **types.ActionExecutionInput, value interface{}) error { 6357 if v == nil { 6358 return fmt.Errorf("unexpected nil of type %T", v) 6359 } 6360 if value == nil { 6361 return nil 6362 } 6363 6364 shape, ok := value.(map[string]interface{}) 6365 if !ok { 6366 return fmt.Errorf("unexpected JSON type %v", value) 6367 } 6368 6369 var sv *types.ActionExecutionInput 6370 if *v == nil { 6371 sv = &types.ActionExecutionInput{} 6372 } else { 6373 sv = *v 6374 } 6375 6376 for key, value := range shape { 6377 switch key { 6378 case "actionTypeId": 6379 if err := awsAwsjson11_deserializeDocumentActionTypeId(&sv.ActionTypeId, value); err != nil { 6380 return err 6381 } 6382 6383 case "configuration": 6384 if err := awsAwsjson11_deserializeDocumentActionConfigurationMap(&sv.Configuration, value); err != nil { 6385 return err 6386 } 6387 6388 case "inputArtifacts": 6389 if err := awsAwsjson11_deserializeDocumentArtifactDetailList(&sv.InputArtifacts, value); err != nil { 6390 return err 6391 } 6392 6393 case "namespace": 6394 if value != nil { 6395 jtv, ok := value.(string) 6396 if !ok { 6397 return fmt.Errorf("expected ActionNamespace to be of type string, got %T instead", value) 6398 } 6399 sv.Namespace = ptr.String(jtv) 6400 } 6401 6402 case "region": 6403 if value != nil { 6404 jtv, ok := value.(string) 6405 if !ok { 6406 return fmt.Errorf("expected AWSRegionName to be of type string, got %T instead", value) 6407 } 6408 sv.Region = ptr.String(jtv) 6409 } 6410 6411 case "resolvedConfiguration": 6412 if err := awsAwsjson11_deserializeDocumentResolvedActionConfigurationMap(&sv.ResolvedConfiguration, value); err != nil { 6413 return err 6414 } 6415 6416 case "roleArn": 6417 if value != nil { 6418 jtv, ok := value.(string) 6419 if !ok { 6420 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 6421 } 6422 sv.RoleArn = ptr.String(jtv) 6423 } 6424 6425 default: 6426 _, _ = key, value 6427 6428 } 6429 } 6430 *v = sv 6431 return nil 6432} 6433 6434func awsAwsjson11_deserializeDocumentActionExecutionOutput(v **types.ActionExecutionOutput, value interface{}) error { 6435 if v == nil { 6436 return fmt.Errorf("unexpected nil of type %T", v) 6437 } 6438 if value == nil { 6439 return nil 6440 } 6441 6442 shape, ok := value.(map[string]interface{}) 6443 if !ok { 6444 return fmt.Errorf("unexpected JSON type %v", value) 6445 } 6446 6447 var sv *types.ActionExecutionOutput 6448 if *v == nil { 6449 sv = &types.ActionExecutionOutput{} 6450 } else { 6451 sv = *v 6452 } 6453 6454 for key, value := range shape { 6455 switch key { 6456 case "executionResult": 6457 if err := awsAwsjson11_deserializeDocumentActionExecutionResult(&sv.ExecutionResult, value); err != nil { 6458 return err 6459 } 6460 6461 case "outputArtifacts": 6462 if err := awsAwsjson11_deserializeDocumentArtifactDetailList(&sv.OutputArtifacts, value); err != nil { 6463 return err 6464 } 6465 6466 case "outputVariables": 6467 if err := awsAwsjson11_deserializeDocumentOutputVariablesMap(&sv.OutputVariables, value); err != nil { 6468 return err 6469 } 6470 6471 default: 6472 _, _ = key, value 6473 6474 } 6475 } 6476 *v = sv 6477 return nil 6478} 6479 6480func awsAwsjson11_deserializeDocumentActionExecutionResult(v **types.ActionExecutionResult, value interface{}) error { 6481 if v == nil { 6482 return fmt.Errorf("unexpected nil of type %T", v) 6483 } 6484 if value == nil { 6485 return nil 6486 } 6487 6488 shape, ok := value.(map[string]interface{}) 6489 if !ok { 6490 return fmt.Errorf("unexpected JSON type %v", value) 6491 } 6492 6493 var sv *types.ActionExecutionResult 6494 if *v == nil { 6495 sv = &types.ActionExecutionResult{} 6496 } else { 6497 sv = *v 6498 } 6499 6500 for key, value := range shape { 6501 switch key { 6502 case "externalExecutionId": 6503 if value != nil { 6504 jtv, ok := value.(string) 6505 if !ok { 6506 return fmt.Errorf("expected ExternalExecutionId to be of type string, got %T instead", value) 6507 } 6508 sv.ExternalExecutionId = ptr.String(jtv) 6509 } 6510 6511 case "externalExecutionSummary": 6512 if value != nil { 6513 jtv, ok := value.(string) 6514 if !ok { 6515 return fmt.Errorf("expected ExternalExecutionSummary to be of type string, got %T instead", value) 6516 } 6517 sv.ExternalExecutionSummary = ptr.String(jtv) 6518 } 6519 6520 case "externalExecutionUrl": 6521 if value != nil { 6522 jtv, ok := value.(string) 6523 if !ok { 6524 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 6525 } 6526 sv.ExternalExecutionUrl = ptr.String(jtv) 6527 } 6528 6529 default: 6530 _, _ = key, value 6531 6532 } 6533 } 6534 *v = sv 6535 return nil 6536} 6537 6538func awsAwsjson11_deserializeDocumentActionNotFoundException(v **types.ActionNotFoundException, value interface{}) error { 6539 if v == nil { 6540 return fmt.Errorf("unexpected nil of type %T", v) 6541 } 6542 if value == nil { 6543 return nil 6544 } 6545 6546 shape, ok := value.(map[string]interface{}) 6547 if !ok { 6548 return fmt.Errorf("unexpected JSON type %v", value) 6549 } 6550 6551 var sv *types.ActionNotFoundException 6552 if *v == nil { 6553 sv = &types.ActionNotFoundException{} 6554 } else { 6555 sv = *v 6556 } 6557 6558 for key, value := range shape { 6559 switch key { 6560 case "message": 6561 if value != nil { 6562 jtv, ok := value.(string) 6563 if !ok { 6564 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 6565 } 6566 sv.Message = ptr.String(jtv) 6567 } 6568 6569 default: 6570 _, _ = key, value 6571 6572 } 6573 } 6574 *v = sv 6575 return nil 6576} 6577 6578func awsAwsjson11_deserializeDocumentActionRevision(v **types.ActionRevision, value interface{}) error { 6579 if v == nil { 6580 return fmt.Errorf("unexpected nil of type %T", v) 6581 } 6582 if value == nil { 6583 return nil 6584 } 6585 6586 shape, ok := value.(map[string]interface{}) 6587 if !ok { 6588 return fmt.Errorf("unexpected JSON type %v", value) 6589 } 6590 6591 var sv *types.ActionRevision 6592 if *v == nil { 6593 sv = &types.ActionRevision{} 6594 } else { 6595 sv = *v 6596 } 6597 6598 for key, value := range shape { 6599 switch key { 6600 case "created": 6601 if value != nil { 6602 jtv, ok := value.(json.Number) 6603 if !ok { 6604 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6605 } 6606 f64, err := jtv.Float64() 6607 if err != nil { 6608 return err 6609 } 6610 sv.Created = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6611 } 6612 6613 case "revisionChangeId": 6614 if value != nil { 6615 jtv, ok := value.(string) 6616 if !ok { 6617 return fmt.Errorf("expected RevisionChangeIdentifier to be of type string, got %T instead", value) 6618 } 6619 sv.RevisionChangeId = ptr.String(jtv) 6620 } 6621 6622 case "revisionId": 6623 if value != nil { 6624 jtv, ok := value.(string) 6625 if !ok { 6626 return fmt.Errorf("expected Revision to be of type string, got %T instead", value) 6627 } 6628 sv.RevisionId = ptr.String(jtv) 6629 } 6630 6631 default: 6632 _, _ = key, value 6633 6634 } 6635 } 6636 *v = sv 6637 return nil 6638} 6639 6640func awsAwsjson11_deserializeDocumentActionState(v **types.ActionState, value interface{}) error { 6641 if v == nil { 6642 return fmt.Errorf("unexpected nil of type %T", v) 6643 } 6644 if value == nil { 6645 return nil 6646 } 6647 6648 shape, ok := value.(map[string]interface{}) 6649 if !ok { 6650 return fmt.Errorf("unexpected JSON type %v", value) 6651 } 6652 6653 var sv *types.ActionState 6654 if *v == nil { 6655 sv = &types.ActionState{} 6656 } else { 6657 sv = *v 6658 } 6659 6660 for key, value := range shape { 6661 switch key { 6662 case "actionName": 6663 if value != nil { 6664 jtv, ok := value.(string) 6665 if !ok { 6666 return fmt.Errorf("expected ActionName to be of type string, got %T instead", value) 6667 } 6668 sv.ActionName = ptr.String(jtv) 6669 } 6670 6671 case "currentRevision": 6672 if err := awsAwsjson11_deserializeDocumentActionRevision(&sv.CurrentRevision, value); err != nil { 6673 return err 6674 } 6675 6676 case "entityUrl": 6677 if value != nil { 6678 jtv, ok := value.(string) 6679 if !ok { 6680 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 6681 } 6682 sv.EntityUrl = ptr.String(jtv) 6683 } 6684 6685 case "latestExecution": 6686 if err := awsAwsjson11_deserializeDocumentActionExecution(&sv.LatestExecution, value); err != nil { 6687 return err 6688 } 6689 6690 case "revisionUrl": 6691 if value != nil { 6692 jtv, ok := value.(string) 6693 if !ok { 6694 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 6695 } 6696 sv.RevisionUrl = ptr.String(jtv) 6697 } 6698 6699 default: 6700 _, _ = key, value 6701 6702 } 6703 } 6704 *v = sv 6705 return nil 6706} 6707 6708func awsAwsjson11_deserializeDocumentActionStateList(v *[]types.ActionState, value interface{}) error { 6709 if v == nil { 6710 return fmt.Errorf("unexpected nil of type %T", v) 6711 } 6712 if value == nil { 6713 return nil 6714 } 6715 6716 shape, ok := value.([]interface{}) 6717 if !ok { 6718 return fmt.Errorf("unexpected JSON type %v", value) 6719 } 6720 6721 var cv []types.ActionState 6722 if *v == nil { 6723 cv = []types.ActionState{} 6724 } else { 6725 cv = *v 6726 } 6727 6728 for _, value := range shape { 6729 var col types.ActionState 6730 destAddr := &col 6731 if err := awsAwsjson11_deserializeDocumentActionState(&destAddr, value); err != nil { 6732 return err 6733 } 6734 col = *destAddr 6735 cv = append(cv, col) 6736 6737 } 6738 *v = cv 6739 return nil 6740} 6741 6742func awsAwsjson11_deserializeDocumentActionType(v **types.ActionType, value interface{}) error { 6743 if v == nil { 6744 return fmt.Errorf("unexpected nil of type %T", v) 6745 } 6746 if value == nil { 6747 return nil 6748 } 6749 6750 shape, ok := value.(map[string]interface{}) 6751 if !ok { 6752 return fmt.Errorf("unexpected JSON type %v", value) 6753 } 6754 6755 var sv *types.ActionType 6756 if *v == nil { 6757 sv = &types.ActionType{} 6758 } else { 6759 sv = *v 6760 } 6761 6762 for key, value := range shape { 6763 switch key { 6764 case "actionConfigurationProperties": 6765 if err := awsAwsjson11_deserializeDocumentActionConfigurationPropertyList(&sv.ActionConfigurationProperties, value); err != nil { 6766 return err 6767 } 6768 6769 case "id": 6770 if err := awsAwsjson11_deserializeDocumentActionTypeId(&sv.Id, value); err != nil { 6771 return err 6772 } 6773 6774 case "inputArtifactDetails": 6775 if err := awsAwsjson11_deserializeDocumentArtifactDetails(&sv.InputArtifactDetails, value); err != nil { 6776 return err 6777 } 6778 6779 case "outputArtifactDetails": 6780 if err := awsAwsjson11_deserializeDocumentArtifactDetails(&sv.OutputArtifactDetails, value); err != nil { 6781 return err 6782 } 6783 6784 case "settings": 6785 if err := awsAwsjson11_deserializeDocumentActionTypeSettings(&sv.Settings, value); err != nil { 6786 return err 6787 } 6788 6789 default: 6790 _, _ = key, value 6791 6792 } 6793 } 6794 *v = sv 6795 return nil 6796} 6797 6798func awsAwsjson11_deserializeDocumentActionTypeArtifactDetails(v **types.ActionTypeArtifactDetails, value interface{}) error { 6799 if v == nil { 6800 return fmt.Errorf("unexpected nil of type %T", v) 6801 } 6802 if value == nil { 6803 return nil 6804 } 6805 6806 shape, ok := value.(map[string]interface{}) 6807 if !ok { 6808 return fmt.Errorf("unexpected JSON type %v", value) 6809 } 6810 6811 var sv *types.ActionTypeArtifactDetails 6812 if *v == nil { 6813 sv = &types.ActionTypeArtifactDetails{} 6814 } else { 6815 sv = *v 6816 } 6817 6818 for key, value := range shape { 6819 switch key { 6820 case "maximumCount": 6821 if value != nil { 6822 jtv, ok := value.(json.Number) 6823 if !ok { 6824 return fmt.Errorf("expected MaximumActionTypeArtifactCount to be json.Number, got %T instead", value) 6825 } 6826 i64, err := jtv.Int64() 6827 if err != nil { 6828 return err 6829 } 6830 sv.MaximumCount = int32(i64) 6831 } 6832 6833 case "minimumCount": 6834 if value != nil { 6835 jtv, ok := value.(json.Number) 6836 if !ok { 6837 return fmt.Errorf("expected MinimumActionTypeArtifactCount to be json.Number, got %T instead", value) 6838 } 6839 i64, err := jtv.Int64() 6840 if err != nil { 6841 return err 6842 } 6843 sv.MinimumCount = int32(i64) 6844 } 6845 6846 default: 6847 _, _ = key, value 6848 6849 } 6850 } 6851 *v = sv 6852 return nil 6853} 6854 6855func awsAwsjson11_deserializeDocumentActionTypeDeclaration(v **types.ActionTypeDeclaration, value interface{}) error { 6856 if v == nil { 6857 return fmt.Errorf("unexpected nil of type %T", v) 6858 } 6859 if value == nil { 6860 return nil 6861 } 6862 6863 shape, ok := value.(map[string]interface{}) 6864 if !ok { 6865 return fmt.Errorf("unexpected JSON type %v", value) 6866 } 6867 6868 var sv *types.ActionTypeDeclaration 6869 if *v == nil { 6870 sv = &types.ActionTypeDeclaration{} 6871 } else { 6872 sv = *v 6873 } 6874 6875 for key, value := range shape { 6876 switch key { 6877 case "description": 6878 if value != nil { 6879 jtv, ok := value.(string) 6880 if !ok { 6881 return fmt.Errorf("expected ActionTypeDescription to be of type string, got %T instead", value) 6882 } 6883 sv.Description = ptr.String(jtv) 6884 } 6885 6886 case "executor": 6887 if err := awsAwsjson11_deserializeDocumentActionTypeExecutor(&sv.Executor, value); err != nil { 6888 return err 6889 } 6890 6891 case "id": 6892 if err := awsAwsjson11_deserializeDocumentActionTypeIdentifier(&sv.Id, value); err != nil { 6893 return err 6894 } 6895 6896 case "inputArtifactDetails": 6897 if err := awsAwsjson11_deserializeDocumentActionTypeArtifactDetails(&sv.InputArtifactDetails, value); err != nil { 6898 return err 6899 } 6900 6901 case "outputArtifactDetails": 6902 if err := awsAwsjson11_deserializeDocumentActionTypeArtifactDetails(&sv.OutputArtifactDetails, value); err != nil { 6903 return err 6904 } 6905 6906 case "permissions": 6907 if err := awsAwsjson11_deserializeDocumentActionTypePermissions(&sv.Permissions, value); err != nil { 6908 return err 6909 } 6910 6911 case "properties": 6912 if err := awsAwsjson11_deserializeDocumentActionTypeProperties(&sv.Properties, value); err != nil { 6913 return err 6914 } 6915 6916 case "urls": 6917 if err := awsAwsjson11_deserializeDocumentActionTypeUrls(&sv.Urls, value); err != nil { 6918 return err 6919 } 6920 6921 default: 6922 _, _ = key, value 6923 6924 } 6925 } 6926 *v = sv 6927 return nil 6928} 6929 6930func awsAwsjson11_deserializeDocumentActionTypeExecutor(v **types.ActionTypeExecutor, value interface{}) error { 6931 if v == nil { 6932 return fmt.Errorf("unexpected nil of type %T", v) 6933 } 6934 if value == nil { 6935 return nil 6936 } 6937 6938 shape, ok := value.(map[string]interface{}) 6939 if !ok { 6940 return fmt.Errorf("unexpected JSON type %v", value) 6941 } 6942 6943 var sv *types.ActionTypeExecutor 6944 if *v == nil { 6945 sv = &types.ActionTypeExecutor{} 6946 } else { 6947 sv = *v 6948 } 6949 6950 for key, value := range shape { 6951 switch key { 6952 case "configuration": 6953 if err := awsAwsjson11_deserializeDocumentExecutorConfiguration(&sv.Configuration, value); err != nil { 6954 return err 6955 } 6956 6957 case "jobTimeout": 6958 if value != nil { 6959 jtv, ok := value.(json.Number) 6960 if !ok { 6961 return fmt.Errorf("expected JobTimeout to be json.Number, got %T instead", value) 6962 } 6963 i64, err := jtv.Int64() 6964 if err != nil { 6965 return err 6966 } 6967 sv.JobTimeout = ptr.Int32(int32(i64)) 6968 } 6969 6970 case "policyStatementsTemplate": 6971 if value != nil { 6972 jtv, ok := value.(string) 6973 if !ok { 6974 return fmt.Errorf("expected PolicyStatementsTemplate to be of type string, got %T instead", value) 6975 } 6976 sv.PolicyStatementsTemplate = ptr.String(jtv) 6977 } 6978 6979 case "type": 6980 if value != nil { 6981 jtv, ok := value.(string) 6982 if !ok { 6983 return fmt.Errorf("expected ExecutorType to be of type string, got %T instead", value) 6984 } 6985 sv.Type = types.ExecutorType(jtv) 6986 } 6987 6988 default: 6989 _, _ = key, value 6990 6991 } 6992 } 6993 *v = sv 6994 return nil 6995} 6996 6997func awsAwsjson11_deserializeDocumentActionTypeId(v **types.ActionTypeId, value interface{}) error { 6998 if v == nil { 6999 return fmt.Errorf("unexpected nil of type %T", v) 7000 } 7001 if value == nil { 7002 return nil 7003 } 7004 7005 shape, ok := value.(map[string]interface{}) 7006 if !ok { 7007 return fmt.Errorf("unexpected JSON type %v", value) 7008 } 7009 7010 var sv *types.ActionTypeId 7011 if *v == nil { 7012 sv = &types.ActionTypeId{} 7013 } else { 7014 sv = *v 7015 } 7016 7017 for key, value := range shape { 7018 switch key { 7019 case "category": 7020 if value != nil { 7021 jtv, ok := value.(string) 7022 if !ok { 7023 return fmt.Errorf("expected ActionCategory to be of type string, got %T instead", value) 7024 } 7025 sv.Category = types.ActionCategory(jtv) 7026 } 7027 7028 case "owner": 7029 if value != nil { 7030 jtv, ok := value.(string) 7031 if !ok { 7032 return fmt.Errorf("expected ActionOwner to be of type string, got %T instead", value) 7033 } 7034 sv.Owner = types.ActionOwner(jtv) 7035 } 7036 7037 case "provider": 7038 if value != nil { 7039 jtv, ok := value.(string) 7040 if !ok { 7041 return fmt.Errorf("expected ActionProvider to be of type string, got %T instead", value) 7042 } 7043 sv.Provider = ptr.String(jtv) 7044 } 7045 7046 case "version": 7047 if value != nil { 7048 jtv, ok := value.(string) 7049 if !ok { 7050 return fmt.Errorf("expected Version to be of type string, got %T instead", value) 7051 } 7052 sv.Version = ptr.String(jtv) 7053 } 7054 7055 default: 7056 _, _ = key, value 7057 7058 } 7059 } 7060 *v = sv 7061 return nil 7062} 7063 7064func awsAwsjson11_deserializeDocumentActionTypeIdentifier(v **types.ActionTypeIdentifier, value interface{}) error { 7065 if v == nil { 7066 return fmt.Errorf("unexpected nil of type %T", v) 7067 } 7068 if value == nil { 7069 return nil 7070 } 7071 7072 shape, ok := value.(map[string]interface{}) 7073 if !ok { 7074 return fmt.Errorf("unexpected JSON type %v", value) 7075 } 7076 7077 var sv *types.ActionTypeIdentifier 7078 if *v == nil { 7079 sv = &types.ActionTypeIdentifier{} 7080 } else { 7081 sv = *v 7082 } 7083 7084 for key, value := range shape { 7085 switch key { 7086 case "category": 7087 if value != nil { 7088 jtv, ok := value.(string) 7089 if !ok { 7090 return fmt.Errorf("expected ActionCategory to be of type string, got %T instead", value) 7091 } 7092 sv.Category = types.ActionCategory(jtv) 7093 } 7094 7095 case "owner": 7096 if value != nil { 7097 jtv, ok := value.(string) 7098 if !ok { 7099 return fmt.Errorf("expected ActionTypeOwner to be of type string, got %T instead", value) 7100 } 7101 sv.Owner = ptr.String(jtv) 7102 } 7103 7104 case "provider": 7105 if value != nil { 7106 jtv, ok := value.(string) 7107 if !ok { 7108 return fmt.Errorf("expected ActionProvider to be of type string, got %T instead", value) 7109 } 7110 sv.Provider = ptr.String(jtv) 7111 } 7112 7113 case "version": 7114 if value != nil { 7115 jtv, ok := value.(string) 7116 if !ok { 7117 return fmt.Errorf("expected Version to be of type string, got %T instead", value) 7118 } 7119 sv.Version = ptr.String(jtv) 7120 } 7121 7122 default: 7123 _, _ = key, value 7124 7125 } 7126 } 7127 *v = sv 7128 return nil 7129} 7130 7131func awsAwsjson11_deserializeDocumentActionTypeList(v *[]types.ActionType, value interface{}) error { 7132 if v == nil { 7133 return fmt.Errorf("unexpected nil of type %T", v) 7134 } 7135 if value == nil { 7136 return nil 7137 } 7138 7139 shape, ok := value.([]interface{}) 7140 if !ok { 7141 return fmt.Errorf("unexpected JSON type %v", value) 7142 } 7143 7144 var cv []types.ActionType 7145 if *v == nil { 7146 cv = []types.ActionType{} 7147 } else { 7148 cv = *v 7149 } 7150 7151 for _, value := range shape { 7152 var col types.ActionType 7153 destAddr := &col 7154 if err := awsAwsjson11_deserializeDocumentActionType(&destAddr, value); err != nil { 7155 return err 7156 } 7157 col = *destAddr 7158 cv = append(cv, col) 7159 7160 } 7161 *v = cv 7162 return nil 7163} 7164 7165func awsAwsjson11_deserializeDocumentActionTypeNotFoundException(v **types.ActionTypeNotFoundException, value interface{}) error { 7166 if v == nil { 7167 return fmt.Errorf("unexpected nil of type %T", v) 7168 } 7169 if value == nil { 7170 return nil 7171 } 7172 7173 shape, ok := value.(map[string]interface{}) 7174 if !ok { 7175 return fmt.Errorf("unexpected JSON type %v", value) 7176 } 7177 7178 var sv *types.ActionTypeNotFoundException 7179 if *v == nil { 7180 sv = &types.ActionTypeNotFoundException{} 7181 } else { 7182 sv = *v 7183 } 7184 7185 for key, value := range shape { 7186 switch key { 7187 case "message": 7188 if value != nil { 7189 jtv, ok := value.(string) 7190 if !ok { 7191 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7192 } 7193 sv.Message = ptr.String(jtv) 7194 } 7195 7196 default: 7197 _, _ = key, value 7198 7199 } 7200 } 7201 *v = sv 7202 return nil 7203} 7204 7205func awsAwsjson11_deserializeDocumentActionTypePermissions(v **types.ActionTypePermissions, value interface{}) error { 7206 if v == nil { 7207 return fmt.Errorf("unexpected nil of type %T", v) 7208 } 7209 if value == nil { 7210 return nil 7211 } 7212 7213 shape, ok := value.(map[string]interface{}) 7214 if !ok { 7215 return fmt.Errorf("unexpected JSON type %v", value) 7216 } 7217 7218 var sv *types.ActionTypePermissions 7219 if *v == nil { 7220 sv = &types.ActionTypePermissions{} 7221 } else { 7222 sv = *v 7223 } 7224 7225 for key, value := range shape { 7226 switch key { 7227 case "allowedAccounts": 7228 if err := awsAwsjson11_deserializeDocumentAllowedAccounts(&sv.AllowedAccounts, value); err != nil { 7229 return err 7230 } 7231 7232 default: 7233 _, _ = key, value 7234 7235 } 7236 } 7237 *v = sv 7238 return nil 7239} 7240 7241func awsAwsjson11_deserializeDocumentActionTypeProperties(v *[]types.ActionTypeProperty, value interface{}) error { 7242 if v == nil { 7243 return fmt.Errorf("unexpected nil of type %T", v) 7244 } 7245 if value == nil { 7246 return nil 7247 } 7248 7249 shape, ok := value.([]interface{}) 7250 if !ok { 7251 return fmt.Errorf("unexpected JSON type %v", value) 7252 } 7253 7254 var cv []types.ActionTypeProperty 7255 if *v == nil { 7256 cv = []types.ActionTypeProperty{} 7257 } else { 7258 cv = *v 7259 } 7260 7261 for _, value := range shape { 7262 var col types.ActionTypeProperty 7263 destAddr := &col 7264 if err := awsAwsjson11_deserializeDocumentActionTypeProperty(&destAddr, value); err != nil { 7265 return err 7266 } 7267 col = *destAddr 7268 cv = append(cv, col) 7269 7270 } 7271 *v = cv 7272 return nil 7273} 7274 7275func awsAwsjson11_deserializeDocumentActionTypeProperty(v **types.ActionTypeProperty, value interface{}) error { 7276 if v == nil { 7277 return fmt.Errorf("unexpected nil of type %T", v) 7278 } 7279 if value == nil { 7280 return nil 7281 } 7282 7283 shape, ok := value.(map[string]interface{}) 7284 if !ok { 7285 return fmt.Errorf("unexpected JSON type %v", value) 7286 } 7287 7288 var sv *types.ActionTypeProperty 7289 if *v == nil { 7290 sv = &types.ActionTypeProperty{} 7291 } else { 7292 sv = *v 7293 } 7294 7295 for key, value := range shape { 7296 switch key { 7297 case "description": 7298 if value != nil { 7299 jtv, ok := value.(string) 7300 if !ok { 7301 return fmt.Errorf("expected PropertyDescription to be of type string, got %T instead", value) 7302 } 7303 sv.Description = ptr.String(jtv) 7304 } 7305 7306 case "key": 7307 if value != nil { 7308 jtv, ok := value.(bool) 7309 if !ok { 7310 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 7311 } 7312 sv.Key = jtv 7313 } 7314 7315 case "name": 7316 if value != nil { 7317 jtv, ok := value.(string) 7318 if !ok { 7319 return fmt.Errorf("expected ActionConfigurationKey to be of type string, got %T instead", value) 7320 } 7321 sv.Name = ptr.String(jtv) 7322 } 7323 7324 case "noEcho": 7325 if value != nil { 7326 jtv, ok := value.(bool) 7327 if !ok { 7328 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 7329 } 7330 sv.NoEcho = jtv 7331 } 7332 7333 case "optional": 7334 if value != nil { 7335 jtv, ok := value.(bool) 7336 if !ok { 7337 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 7338 } 7339 sv.Optional = jtv 7340 } 7341 7342 case "queryable": 7343 if value != nil { 7344 jtv, ok := value.(bool) 7345 if !ok { 7346 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 7347 } 7348 sv.Queryable = jtv 7349 } 7350 7351 default: 7352 _, _ = key, value 7353 7354 } 7355 } 7356 *v = sv 7357 return nil 7358} 7359 7360func awsAwsjson11_deserializeDocumentActionTypeSettings(v **types.ActionTypeSettings, value interface{}) error { 7361 if v == nil { 7362 return fmt.Errorf("unexpected nil of type %T", v) 7363 } 7364 if value == nil { 7365 return nil 7366 } 7367 7368 shape, ok := value.(map[string]interface{}) 7369 if !ok { 7370 return fmt.Errorf("unexpected JSON type %v", value) 7371 } 7372 7373 var sv *types.ActionTypeSettings 7374 if *v == nil { 7375 sv = &types.ActionTypeSettings{} 7376 } else { 7377 sv = *v 7378 } 7379 7380 for key, value := range shape { 7381 switch key { 7382 case "entityUrlTemplate": 7383 if value != nil { 7384 jtv, ok := value.(string) 7385 if !ok { 7386 return fmt.Errorf("expected UrlTemplate to be of type string, got %T instead", value) 7387 } 7388 sv.EntityUrlTemplate = ptr.String(jtv) 7389 } 7390 7391 case "executionUrlTemplate": 7392 if value != nil { 7393 jtv, ok := value.(string) 7394 if !ok { 7395 return fmt.Errorf("expected UrlTemplate to be of type string, got %T instead", value) 7396 } 7397 sv.ExecutionUrlTemplate = ptr.String(jtv) 7398 } 7399 7400 case "revisionUrlTemplate": 7401 if value != nil { 7402 jtv, ok := value.(string) 7403 if !ok { 7404 return fmt.Errorf("expected UrlTemplate to be of type string, got %T instead", value) 7405 } 7406 sv.RevisionUrlTemplate = ptr.String(jtv) 7407 } 7408 7409 case "thirdPartyConfigurationUrl": 7410 if value != nil { 7411 jtv, ok := value.(string) 7412 if !ok { 7413 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 7414 } 7415 sv.ThirdPartyConfigurationUrl = ptr.String(jtv) 7416 } 7417 7418 default: 7419 _, _ = key, value 7420 7421 } 7422 } 7423 *v = sv 7424 return nil 7425} 7426 7427func awsAwsjson11_deserializeDocumentActionTypeUrls(v **types.ActionTypeUrls, value interface{}) error { 7428 if v == nil { 7429 return fmt.Errorf("unexpected nil of type %T", v) 7430 } 7431 if value == nil { 7432 return nil 7433 } 7434 7435 shape, ok := value.(map[string]interface{}) 7436 if !ok { 7437 return fmt.Errorf("unexpected JSON type %v", value) 7438 } 7439 7440 var sv *types.ActionTypeUrls 7441 if *v == nil { 7442 sv = &types.ActionTypeUrls{} 7443 } else { 7444 sv = *v 7445 } 7446 7447 for key, value := range shape { 7448 switch key { 7449 case "configurationUrl": 7450 if value != nil { 7451 jtv, ok := value.(string) 7452 if !ok { 7453 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 7454 } 7455 sv.ConfigurationUrl = ptr.String(jtv) 7456 } 7457 7458 case "entityUrlTemplate": 7459 if value != nil { 7460 jtv, ok := value.(string) 7461 if !ok { 7462 return fmt.Errorf("expected UrlTemplate to be of type string, got %T instead", value) 7463 } 7464 sv.EntityUrlTemplate = ptr.String(jtv) 7465 } 7466 7467 case "executionUrlTemplate": 7468 if value != nil { 7469 jtv, ok := value.(string) 7470 if !ok { 7471 return fmt.Errorf("expected UrlTemplate to be of type string, got %T instead", value) 7472 } 7473 sv.ExecutionUrlTemplate = ptr.String(jtv) 7474 } 7475 7476 case "revisionUrlTemplate": 7477 if value != nil { 7478 jtv, ok := value.(string) 7479 if !ok { 7480 return fmt.Errorf("expected UrlTemplate to be of type string, got %T instead", value) 7481 } 7482 sv.RevisionUrlTemplate = ptr.String(jtv) 7483 } 7484 7485 default: 7486 _, _ = key, value 7487 7488 } 7489 } 7490 *v = sv 7491 return nil 7492} 7493 7494func awsAwsjson11_deserializeDocumentAllowedAccounts(v *[]string, value interface{}) error { 7495 if v == nil { 7496 return fmt.Errorf("unexpected nil of type %T", v) 7497 } 7498 if value == nil { 7499 return nil 7500 } 7501 7502 shape, ok := value.([]interface{}) 7503 if !ok { 7504 return fmt.Errorf("unexpected JSON type %v", value) 7505 } 7506 7507 var cv []string 7508 if *v == nil { 7509 cv = []string{} 7510 } else { 7511 cv = *v 7512 } 7513 7514 for _, value := range shape { 7515 var col string 7516 if value != nil { 7517 jtv, ok := value.(string) 7518 if !ok { 7519 return fmt.Errorf("expected AllowedAccount to be of type string, got %T instead", value) 7520 } 7521 col = jtv 7522 } 7523 cv = append(cv, col) 7524 7525 } 7526 *v = cv 7527 return nil 7528} 7529 7530func awsAwsjson11_deserializeDocumentApprovalAlreadyCompletedException(v **types.ApprovalAlreadyCompletedException, value interface{}) error { 7531 if v == nil { 7532 return fmt.Errorf("unexpected nil of type %T", v) 7533 } 7534 if value == nil { 7535 return nil 7536 } 7537 7538 shape, ok := value.(map[string]interface{}) 7539 if !ok { 7540 return fmt.Errorf("unexpected JSON type %v", value) 7541 } 7542 7543 var sv *types.ApprovalAlreadyCompletedException 7544 if *v == nil { 7545 sv = &types.ApprovalAlreadyCompletedException{} 7546 } else { 7547 sv = *v 7548 } 7549 7550 for key, value := range shape { 7551 switch key { 7552 case "message": 7553 if value != nil { 7554 jtv, ok := value.(string) 7555 if !ok { 7556 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7557 } 7558 sv.Message = ptr.String(jtv) 7559 } 7560 7561 default: 7562 _, _ = key, value 7563 7564 } 7565 } 7566 *v = sv 7567 return nil 7568} 7569 7570func awsAwsjson11_deserializeDocumentArtifact(v **types.Artifact, value interface{}) error { 7571 if v == nil { 7572 return fmt.Errorf("unexpected nil of type %T", v) 7573 } 7574 if value == nil { 7575 return nil 7576 } 7577 7578 shape, ok := value.(map[string]interface{}) 7579 if !ok { 7580 return fmt.Errorf("unexpected JSON type %v", value) 7581 } 7582 7583 var sv *types.Artifact 7584 if *v == nil { 7585 sv = &types.Artifact{} 7586 } else { 7587 sv = *v 7588 } 7589 7590 for key, value := range shape { 7591 switch key { 7592 case "location": 7593 if err := awsAwsjson11_deserializeDocumentArtifactLocation(&sv.Location, value); err != nil { 7594 return err 7595 } 7596 7597 case "name": 7598 if value != nil { 7599 jtv, ok := value.(string) 7600 if !ok { 7601 return fmt.Errorf("expected ArtifactName to be of type string, got %T instead", value) 7602 } 7603 sv.Name = ptr.String(jtv) 7604 } 7605 7606 case "revision": 7607 if value != nil { 7608 jtv, ok := value.(string) 7609 if !ok { 7610 return fmt.Errorf("expected Revision to be of type string, got %T instead", value) 7611 } 7612 sv.Revision = ptr.String(jtv) 7613 } 7614 7615 default: 7616 _, _ = key, value 7617 7618 } 7619 } 7620 *v = sv 7621 return nil 7622} 7623 7624func awsAwsjson11_deserializeDocumentArtifactDetail(v **types.ArtifactDetail, value interface{}) error { 7625 if v == nil { 7626 return fmt.Errorf("unexpected nil of type %T", v) 7627 } 7628 if value == nil { 7629 return nil 7630 } 7631 7632 shape, ok := value.(map[string]interface{}) 7633 if !ok { 7634 return fmt.Errorf("unexpected JSON type %v", value) 7635 } 7636 7637 var sv *types.ArtifactDetail 7638 if *v == nil { 7639 sv = &types.ArtifactDetail{} 7640 } else { 7641 sv = *v 7642 } 7643 7644 for key, value := range shape { 7645 switch key { 7646 case "name": 7647 if value != nil { 7648 jtv, ok := value.(string) 7649 if !ok { 7650 return fmt.Errorf("expected ArtifactName to be of type string, got %T instead", value) 7651 } 7652 sv.Name = ptr.String(jtv) 7653 } 7654 7655 case "s3location": 7656 if err := awsAwsjson11_deserializeDocumentS3Location(&sv.S3location, value); err != nil { 7657 return err 7658 } 7659 7660 default: 7661 _, _ = key, value 7662 7663 } 7664 } 7665 *v = sv 7666 return nil 7667} 7668 7669func awsAwsjson11_deserializeDocumentArtifactDetailList(v *[]types.ArtifactDetail, value interface{}) error { 7670 if v == nil { 7671 return fmt.Errorf("unexpected nil of type %T", v) 7672 } 7673 if value == nil { 7674 return nil 7675 } 7676 7677 shape, ok := value.([]interface{}) 7678 if !ok { 7679 return fmt.Errorf("unexpected JSON type %v", value) 7680 } 7681 7682 var cv []types.ArtifactDetail 7683 if *v == nil { 7684 cv = []types.ArtifactDetail{} 7685 } else { 7686 cv = *v 7687 } 7688 7689 for _, value := range shape { 7690 var col types.ArtifactDetail 7691 destAddr := &col 7692 if err := awsAwsjson11_deserializeDocumentArtifactDetail(&destAddr, value); err != nil { 7693 return err 7694 } 7695 col = *destAddr 7696 cv = append(cv, col) 7697 7698 } 7699 *v = cv 7700 return nil 7701} 7702 7703func awsAwsjson11_deserializeDocumentArtifactDetails(v **types.ArtifactDetails, value interface{}) error { 7704 if v == nil { 7705 return fmt.Errorf("unexpected nil of type %T", v) 7706 } 7707 if value == nil { 7708 return nil 7709 } 7710 7711 shape, ok := value.(map[string]interface{}) 7712 if !ok { 7713 return fmt.Errorf("unexpected JSON type %v", value) 7714 } 7715 7716 var sv *types.ArtifactDetails 7717 if *v == nil { 7718 sv = &types.ArtifactDetails{} 7719 } else { 7720 sv = *v 7721 } 7722 7723 for key, value := range shape { 7724 switch key { 7725 case "maximumCount": 7726 if value != nil { 7727 jtv, ok := value.(json.Number) 7728 if !ok { 7729 return fmt.Errorf("expected MaximumArtifactCount to be json.Number, got %T instead", value) 7730 } 7731 i64, err := jtv.Int64() 7732 if err != nil { 7733 return err 7734 } 7735 sv.MaximumCount = int32(i64) 7736 } 7737 7738 case "minimumCount": 7739 if value != nil { 7740 jtv, ok := value.(json.Number) 7741 if !ok { 7742 return fmt.Errorf("expected MinimumArtifactCount to be json.Number, got %T instead", value) 7743 } 7744 i64, err := jtv.Int64() 7745 if err != nil { 7746 return err 7747 } 7748 sv.MinimumCount = int32(i64) 7749 } 7750 7751 default: 7752 _, _ = key, value 7753 7754 } 7755 } 7756 *v = sv 7757 return nil 7758} 7759 7760func awsAwsjson11_deserializeDocumentArtifactList(v *[]types.Artifact, value interface{}) error { 7761 if v == nil { 7762 return fmt.Errorf("unexpected nil of type %T", v) 7763 } 7764 if value == nil { 7765 return nil 7766 } 7767 7768 shape, ok := value.([]interface{}) 7769 if !ok { 7770 return fmt.Errorf("unexpected JSON type %v", value) 7771 } 7772 7773 var cv []types.Artifact 7774 if *v == nil { 7775 cv = []types.Artifact{} 7776 } else { 7777 cv = *v 7778 } 7779 7780 for _, value := range shape { 7781 var col types.Artifact 7782 destAddr := &col 7783 if err := awsAwsjson11_deserializeDocumentArtifact(&destAddr, value); err != nil { 7784 return err 7785 } 7786 col = *destAddr 7787 cv = append(cv, col) 7788 7789 } 7790 *v = cv 7791 return nil 7792} 7793 7794func awsAwsjson11_deserializeDocumentArtifactLocation(v **types.ArtifactLocation, value interface{}) error { 7795 if v == nil { 7796 return fmt.Errorf("unexpected nil of type %T", v) 7797 } 7798 if value == nil { 7799 return nil 7800 } 7801 7802 shape, ok := value.(map[string]interface{}) 7803 if !ok { 7804 return fmt.Errorf("unexpected JSON type %v", value) 7805 } 7806 7807 var sv *types.ArtifactLocation 7808 if *v == nil { 7809 sv = &types.ArtifactLocation{} 7810 } else { 7811 sv = *v 7812 } 7813 7814 for key, value := range shape { 7815 switch key { 7816 case "s3Location": 7817 if err := awsAwsjson11_deserializeDocumentS3ArtifactLocation(&sv.S3Location, value); err != nil { 7818 return err 7819 } 7820 7821 case "type": 7822 if value != nil { 7823 jtv, ok := value.(string) 7824 if !ok { 7825 return fmt.Errorf("expected ArtifactLocationType to be of type string, got %T instead", value) 7826 } 7827 sv.Type = types.ArtifactLocationType(jtv) 7828 } 7829 7830 default: 7831 _, _ = key, value 7832 7833 } 7834 } 7835 *v = sv 7836 return nil 7837} 7838 7839func awsAwsjson11_deserializeDocumentArtifactRevision(v **types.ArtifactRevision, value interface{}) error { 7840 if v == nil { 7841 return fmt.Errorf("unexpected nil of type %T", v) 7842 } 7843 if value == nil { 7844 return nil 7845 } 7846 7847 shape, ok := value.(map[string]interface{}) 7848 if !ok { 7849 return fmt.Errorf("unexpected JSON type %v", value) 7850 } 7851 7852 var sv *types.ArtifactRevision 7853 if *v == nil { 7854 sv = &types.ArtifactRevision{} 7855 } else { 7856 sv = *v 7857 } 7858 7859 for key, value := range shape { 7860 switch key { 7861 case "created": 7862 if value != nil { 7863 jtv, ok := value.(json.Number) 7864 if !ok { 7865 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7866 } 7867 f64, err := jtv.Float64() 7868 if err != nil { 7869 return err 7870 } 7871 sv.Created = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7872 } 7873 7874 case "name": 7875 if value != nil { 7876 jtv, ok := value.(string) 7877 if !ok { 7878 return fmt.Errorf("expected ArtifactName to be of type string, got %T instead", value) 7879 } 7880 sv.Name = ptr.String(jtv) 7881 } 7882 7883 case "revisionChangeIdentifier": 7884 if value != nil { 7885 jtv, ok := value.(string) 7886 if !ok { 7887 return fmt.Errorf("expected RevisionChangeIdentifier to be of type string, got %T instead", value) 7888 } 7889 sv.RevisionChangeIdentifier = ptr.String(jtv) 7890 } 7891 7892 case "revisionId": 7893 if value != nil { 7894 jtv, ok := value.(string) 7895 if !ok { 7896 return fmt.Errorf("expected Revision to be of type string, got %T instead", value) 7897 } 7898 sv.RevisionId = ptr.String(jtv) 7899 } 7900 7901 case "revisionSummary": 7902 if value != nil { 7903 jtv, ok := value.(string) 7904 if !ok { 7905 return fmt.Errorf("expected RevisionSummary to be of type string, got %T instead", value) 7906 } 7907 sv.RevisionSummary = ptr.String(jtv) 7908 } 7909 7910 case "revisionUrl": 7911 if value != nil { 7912 jtv, ok := value.(string) 7913 if !ok { 7914 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 7915 } 7916 sv.RevisionUrl = ptr.String(jtv) 7917 } 7918 7919 default: 7920 _, _ = key, value 7921 7922 } 7923 } 7924 *v = sv 7925 return nil 7926} 7927 7928func awsAwsjson11_deserializeDocumentArtifactRevisionList(v *[]types.ArtifactRevision, value interface{}) error { 7929 if v == nil { 7930 return fmt.Errorf("unexpected nil of type %T", v) 7931 } 7932 if value == nil { 7933 return nil 7934 } 7935 7936 shape, ok := value.([]interface{}) 7937 if !ok { 7938 return fmt.Errorf("unexpected JSON type %v", value) 7939 } 7940 7941 var cv []types.ArtifactRevision 7942 if *v == nil { 7943 cv = []types.ArtifactRevision{} 7944 } else { 7945 cv = *v 7946 } 7947 7948 for _, value := range shape { 7949 var col types.ArtifactRevision 7950 destAddr := &col 7951 if err := awsAwsjson11_deserializeDocumentArtifactRevision(&destAddr, value); err != nil { 7952 return err 7953 } 7954 col = *destAddr 7955 cv = append(cv, col) 7956 7957 } 7958 *v = cv 7959 return nil 7960} 7961 7962func awsAwsjson11_deserializeDocumentArtifactStore(v **types.ArtifactStore, value interface{}) error { 7963 if v == nil { 7964 return fmt.Errorf("unexpected nil of type %T", v) 7965 } 7966 if value == nil { 7967 return nil 7968 } 7969 7970 shape, ok := value.(map[string]interface{}) 7971 if !ok { 7972 return fmt.Errorf("unexpected JSON type %v", value) 7973 } 7974 7975 var sv *types.ArtifactStore 7976 if *v == nil { 7977 sv = &types.ArtifactStore{} 7978 } else { 7979 sv = *v 7980 } 7981 7982 for key, value := range shape { 7983 switch key { 7984 case "encryptionKey": 7985 if err := awsAwsjson11_deserializeDocumentEncryptionKey(&sv.EncryptionKey, value); err != nil { 7986 return err 7987 } 7988 7989 case "location": 7990 if value != nil { 7991 jtv, ok := value.(string) 7992 if !ok { 7993 return fmt.Errorf("expected ArtifactStoreLocation to be of type string, got %T instead", value) 7994 } 7995 sv.Location = ptr.String(jtv) 7996 } 7997 7998 case "type": 7999 if value != nil { 8000 jtv, ok := value.(string) 8001 if !ok { 8002 return fmt.Errorf("expected ArtifactStoreType to be of type string, got %T instead", value) 8003 } 8004 sv.Type = types.ArtifactStoreType(jtv) 8005 } 8006 8007 default: 8008 _, _ = key, value 8009 8010 } 8011 } 8012 *v = sv 8013 return nil 8014} 8015 8016func awsAwsjson11_deserializeDocumentArtifactStoreMap(v *map[string]types.ArtifactStore, value interface{}) error { 8017 if v == nil { 8018 return fmt.Errorf("unexpected nil of type %T", v) 8019 } 8020 if value == nil { 8021 return nil 8022 } 8023 8024 shape, ok := value.(map[string]interface{}) 8025 if !ok { 8026 return fmt.Errorf("unexpected JSON type %v", value) 8027 } 8028 8029 var mv map[string]types.ArtifactStore 8030 if *v == nil { 8031 mv = map[string]types.ArtifactStore{} 8032 } else { 8033 mv = *v 8034 } 8035 8036 for key, value := range shape { 8037 var parsedVal types.ArtifactStore 8038 mapVar := parsedVal 8039 destAddr := &mapVar 8040 if err := awsAwsjson11_deserializeDocumentArtifactStore(&destAddr, value); err != nil { 8041 return err 8042 } 8043 parsedVal = *destAddr 8044 mv[key] = parsedVal 8045 8046 } 8047 *v = mv 8048 return nil 8049} 8050 8051func awsAwsjson11_deserializeDocumentAWSSessionCredentials(v **types.AWSSessionCredentials, value interface{}) error { 8052 if v == nil { 8053 return fmt.Errorf("unexpected nil of type %T", v) 8054 } 8055 if value == nil { 8056 return nil 8057 } 8058 8059 shape, ok := value.(map[string]interface{}) 8060 if !ok { 8061 return fmt.Errorf("unexpected JSON type %v", value) 8062 } 8063 8064 var sv *types.AWSSessionCredentials 8065 if *v == nil { 8066 sv = &types.AWSSessionCredentials{} 8067 } else { 8068 sv = *v 8069 } 8070 8071 for key, value := range shape { 8072 switch key { 8073 case "accessKeyId": 8074 if value != nil { 8075 jtv, ok := value.(string) 8076 if !ok { 8077 return fmt.Errorf("expected AccessKeyId to be of type string, got %T instead", value) 8078 } 8079 sv.AccessKeyId = ptr.String(jtv) 8080 } 8081 8082 case "secretAccessKey": 8083 if value != nil { 8084 jtv, ok := value.(string) 8085 if !ok { 8086 return fmt.Errorf("expected SecretAccessKey to be of type string, got %T instead", value) 8087 } 8088 sv.SecretAccessKey = ptr.String(jtv) 8089 } 8090 8091 case "sessionToken": 8092 if value != nil { 8093 jtv, ok := value.(string) 8094 if !ok { 8095 return fmt.Errorf("expected SessionToken to be of type string, got %T instead", value) 8096 } 8097 sv.SessionToken = ptr.String(jtv) 8098 } 8099 8100 default: 8101 _, _ = key, value 8102 8103 } 8104 } 8105 *v = sv 8106 return nil 8107} 8108 8109func awsAwsjson11_deserializeDocumentBlockerDeclaration(v **types.BlockerDeclaration, value interface{}) error { 8110 if v == nil { 8111 return fmt.Errorf("unexpected nil of type %T", v) 8112 } 8113 if value == nil { 8114 return nil 8115 } 8116 8117 shape, ok := value.(map[string]interface{}) 8118 if !ok { 8119 return fmt.Errorf("unexpected JSON type %v", value) 8120 } 8121 8122 var sv *types.BlockerDeclaration 8123 if *v == nil { 8124 sv = &types.BlockerDeclaration{} 8125 } else { 8126 sv = *v 8127 } 8128 8129 for key, value := range shape { 8130 switch key { 8131 case "name": 8132 if value != nil { 8133 jtv, ok := value.(string) 8134 if !ok { 8135 return fmt.Errorf("expected BlockerName to be of type string, got %T instead", value) 8136 } 8137 sv.Name = ptr.String(jtv) 8138 } 8139 8140 case "type": 8141 if value != nil { 8142 jtv, ok := value.(string) 8143 if !ok { 8144 return fmt.Errorf("expected BlockerType to be of type string, got %T instead", value) 8145 } 8146 sv.Type = types.BlockerType(jtv) 8147 } 8148 8149 default: 8150 _, _ = key, value 8151 8152 } 8153 } 8154 *v = sv 8155 return nil 8156} 8157 8158func awsAwsjson11_deserializeDocumentConcurrentModificationException(v **types.ConcurrentModificationException, value interface{}) error { 8159 if v == nil { 8160 return fmt.Errorf("unexpected nil of type %T", v) 8161 } 8162 if value == nil { 8163 return nil 8164 } 8165 8166 shape, ok := value.(map[string]interface{}) 8167 if !ok { 8168 return fmt.Errorf("unexpected JSON type %v", value) 8169 } 8170 8171 var sv *types.ConcurrentModificationException 8172 if *v == nil { 8173 sv = &types.ConcurrentModificationException{} 8174 } else { 8175 sv = *v 8176 } 8177 8178 for key, value := range shape { 8179 switch key { 8180 case "message": 8181 if value != nil { 8182 jtv, ok := value.(string) 8183 if !ok { 8184 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8185 } 8186 sv.Message = ptr.String(jtv) 8187 } 8188 8189 default: 8190 _, _ = key, value 8191 8192 } 8193 } 8194 *v = sv 8195 return nil 8196} 8197 8198func awsAwsjson11_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { 8199 if v == nil { 8200 return fmt.Errorf("unexpected nil of type %T", v) 8201 } 8202 if value == nil { 8203 return nil 8204 } 8205 8206 shape, ok := value.(map[string]interface{}) 8207 if !ok { 8208 return fmt.Errorf("unexpected JSON type %v", value) 8209 } 8210 8211 var sv *types.ConflictException 8212 if *v == nil { 8213 sv = &types.ConflictException{} 8214 } else { 8215 sv = *v 8216 } 8217 8218 for key, value := range shape { 8219 switch key { 8220 case "message": 8221 if value != nil { 8222 jtv, ok := value.(string) 8223 if !ok { 8224 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8225 } 8226 sv.Message = ptr.String(jtv) 8227 } 8228 8229 default: 8230 _, _ = key, value 8231 8232 } 8233 } 8234 *v = sv 8235 return nil 8236} 8237 8238func awsAwsjson11_deserializeDocumentDuplicatedStopRequestException(v **types.DuplicatedStopRequestException, value interface{}) error { 8239 if v == nil { 8240 return fmt.Errorf("unexpected nil of type %T", v) 8241 } 8242 if value == nil { 8243 return nil 8244 } 8245 8246 shape, ok := value.(map[string]interface{}) 8247 if !ok { 8248 return fmt.Errorf("unexpected JSON type %v", value) 8249 } 8250 8251 var sv *types.DuplicatedStopRequestException 8252 if *v == nil { 8253 sv = &types.DuplicatedStopRequestException{} 8254 } else { 8255 sv = *v 8256 } 8257 8258 for key, value := range shape { 8259 switch key { 8260 case "message": 8261 if value != nil { 8262 jtv, ok := value.(string) 8263 if !ok { 8264 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8265 } 8266 sv.Message = ptr.String(jtv) 8267 } 8268 8269 default: 8270 _, _ = key, value 8271 8272 } 8273 } 8274 *v = sv 8275 return nil 8276} 8277 8278func awsAwsjson11_deserializeDocumentEncryptionKey(v **types.EncryptionKey, value interface{}) error { 8279 if v == nil { 8280 return fmt.Errorf("unexpected nil of type %T", v) 8281 } 8282 if value == nil { 8283 return nil 8284 } 8285 8286 shape, ok := value.(map[string]interface{}) 8287 if !ok { 8288 return fmt.Errorf("unexpected JSON type %v", value) 8289 } 8290 8291 var sv *types.EncryptionKey 8292 if *v == nil { 8293 sv = &types.EncryptionKey{} 8294 } else { 8295 sv = *v 8296 } 8297 8298 for key, value := range shape { 8299 switch key { 8300 case "id": 8301 if value != nil { 8302 jtv, ok := value.(string) 8303 if !ok { 8304 return fmt.Errorf("expected EncryptionKeyId to be of type string, got %T instead", value) 8305 } 8306 sv.Id = ptr.String(jtv) 8307 } 8308 8309 case "type": 8310 if value != nil { 8311 jtv, ok := value.(string) 8312 if !ok { 8313 return fmt.Errorf("expected EncryptionKeyType to be of type string, got %T instead", value) 8314 } 8315 sv.Type = types.EncryptionKeyType(jtv) 8316 } 8317 8318 default: 8319 _, _ = key, value 8320 8321 } 8322 } 8323 *v = sv 8324 return nil 8325} 8326 8327func awsAwsjson11_deserializeDocumentErrorDetails(v **types.ErrorDetails, value interface{}) error { 8328 if v == nil { 8329 return fmt.Errorf("unexpected nil of type %T", v) 8330 } 8331 if value == nil { 8332 return nil 8333 } 8334 8335 shape, ok := value.(map[string]interface{}) 8336 if !ok { 8337 return fmt.Errorf("unexpected JSON type %v", value) 8338 } 8339 8340 var sv *types.ErrorDetails 8341 if *v == nil { 8342 sv = &types.ErrorDetails{} 8343 } else { 8344 sv = *v 8345 } 8346 8347 for key, value := range shape { 8348 switch key { 8349 case "code": 8350 if value != nil { 8351 jtv, ok := value.(string) 8352 if !ok { 8353 return fmt.Errorf("expected Code to be of type string, got %T instead", value) 8354 } 8355 sv.Code = ptr.String(jtv) 8356 } 8357 8358 case "message": 8359 if value != nil { 8360 jtv, ok := value.(string) 8361 if !ok { 8362 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8363 } 8364 sv.Message = ptr.String(jtv) 8365 } 8366 8367 default: 8368 _, _ = key, value 8369 8370 } 8371 } 8372 *v = sv 8373 return nil 8374} 8375 8376func awsAwsjson11_deserializeDocumentExecutionTrigger(v **types.ExecutionTrigger, value interface{}) error { 8377 if v == nil { 8378 return fmt.Errorf("unexpected nil of type %T", v) 8379 } 8380 if value == nil { 8381 return nil 8382 } 8383 8384 shape, ok := value.(map[string]interface{}) 8385 if !ok { 8386 return fmt.Errorf("unexpected JSON type %v", value) 8387 } 8388 8389 var sv *types.ExecutionTrigger 8390 if *v == nil { 8391 sv = &types.ExecutionTrigger{} 8392 } else { 8393 sv = *v 8394 } 8395 8396 for key, value := range shape { 8397 switch key { 8398 case "triggerDetail": 8399 if value != nil { 8400 jtv, ok := value.(string) 8401 if !ok { 8402 return fmt.Errorf("expected TriggerDetail to be of type string, got %T instead", value) 8403 } 8404 sv.TriggerDetail = ptr.String(jtv) 8405 } 8406 8407 case "triggerType": 8408 if value != nil { 8409 jtv, ok := value.(string) 8410 if !ok { 8411 return fmt.Errorf("expected TriggerType to be of type string, got %T instead", value) 8412 } 8413 sv.TriggerType = types.TriggerType(jtv) 8414 } 8415 8416 default: 8417 _, _ = key, value 8418 8419 } 8420 } 8421 *v = sv 8422 return nil 8423} 8424 8425func awsAwsjson11_deserializeDocumentExecutorConfiguration(v **types.ExecutorConfiguration, value interface{}) error { 8426 if v == nil { 8427 return fmt.Errorf("unexpected nil of type %T", v) 8428 } 8429 if value == nil { 8430 return nil 8431 } 8432 8433 shape, ok := value.(map[string]interface{}) 8434 if !ok { 8435 return fmt.Errorf("unexpected JSON type %v", value) 8436 } 8437 8438 var sv *types.ExecutorConfiguration 8439 if *v == nil { 8440 sv = &types.ExecutorConfiguration{} 8441 } else { 8442 sv = *v 8443 } 8444 8445 for key, value := range shape { 8446 switch key { 8447 case "jobWorkerExecutorConfiguration": 8448 if err := awsAwsjson11_deserializeDocumentJobWorkerExecutorConfiguration(&sv.JobWorkerExecutorConfiguration, value); err != nil { 8449 return err 8450 } 8451 8452 case "lambdaExecutorConfiguration": 8453 if err := awsAwsjson11_deserializeDocumentLambdaExecutorConfiguration(&sv.LambdaExecutorConfiguration, value); err != nil { 8454 return err 8455 } 8456 8457 default: 8458 _, _ = key, value 8459 8460 } 8461 } 8462 *v = sv 8463 return nil 8464} 8465 8466func awsAwsjson11_deserializeDocumentInputArtifact(v **types.InputArtifact, value interface{}) error { 8467 if v == nil { 8468 return fmt.Errorf("unexpected nil of type %T", v) 8469 } 8470 if value == nil { 8471 return nil 8472 } 8473 8474 shape, ok := value.(map[string]interface{}) 8475 if !ok { 8476 return fmt.Errorf("unexpected JSON type %v", value) 8477 } 8478 8479 var sv *types.InputArtifact 8480 if *v == nil { 8481 sv = &types.InputArtifact{} 8482 } else { 8483 sv = *v 8484 } 8485 8486 for key, value := range shape { 8487 switch key { 8488 case "name": 8489 if value != nil { 8490 jtv, ok := value.(string) 8491 if !ok { 8492 return fmt.Errorf("expected ArtifactName to be of type string, got %T instead", value) 8493 } 8494 sv.Name = ptr.String(jtv) 8495 } 8496 8497 default: 8498 _, _ = key, value 8499 8500 } 8501 } 8502 *v = sv 8503 return nil 8504} 8505 8506func awsAwsjson11_deserializeDocumentInputArtifactList(v *[]types.InputArtifact, value interface{}) error { 8507 if v == nil { 8508 return fmt.Errorf("unexpected nil of type %T", v) 8509 } 8510 if value == nil { 8511 return nil 8512 } 8513 8514 shape, ok := value.([]interface{}) 8515 if !ok { 8516 return fmt.Errorf("unexpected JSON type %v", value) 8517 } 8518 8519 var cv []types.InputArtifact 8520 if *v == nil { 8521 cv = []types.InputArtifact{} 8522 } else { 8523 cv = *v 8524 } 8525 8526 for _, value := range shape { 8527 var col types.InputArtifact 8528 destAddr := &col 8529 if err := awsAwsjson11_deserializeDocumentInputArtifact(&destAddr, value); err != nil { 8530 return err 8531 } 8532 col = *destAddr 8533 cv = append(cv, col) 8534 8535 } 8536 *v = cv 8537 return nil 8538} 8539 8540func awsAwsjson11_deserializeDocumentInvalidActionDeclarationException(v **types.InvalidActionDeclarationException, value interface{}) error { 8541 if v == nil { 8542 return fmt.Errorf("unexpected nil of type %T", v) 8543 } 8544 if value == nil { 8545 return nil 8546 } 8547 8548 shape, ok := value.(map[string]interface{}) 8549 if !ok { 8550 return fmt.Errorf("unexpected JSON type %v", value) 8551 } 8552 8553 var sv *types.InvalidActionDeclarationException 8554 if *v == nil { 8555 sv = &types.InvalidActionDeclarationException{} 8556 } else { 8557 sv = *v 8558 } 8559 8560 for key, value := range shape { 8561 switch key { 8562 case "message": 8563 if value != nil { 8564 jtv, ok := value.(string) 8565 if !ok { 8566 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8567 } 8568 sv.Message = ptr.String(jtv) 8569 } 8570 8571 default: 8572 _, _ = key, value 8573 8574 } 8575 } 8576 *v = sv 8577 return nil 8578} 8579 8580func awsAwsjson11_deserializeDocumentInvalidApprovalTokenException(v **types.InvalidApprovalTokenException, value interface{}) error { 8581 if v == nil { 8582 return fmt.Errorf("unexpected nil of type %T", v) 8583 } 8584 if value == nil { 8585 return nil 8586 } 8587 8588 shape, ok := value.(map[string]interface{}) 8589 if !ok { 8590 return fmt.Errorf("unexpected JSON type %v", value) 8591 } 8592 8593 var sv *types.InvalidApprovalTokenException 8594 if *v == nil { 8595 sv = &types.InvalidApprovalTokenException{} 8596 } else { 8597 sv = *v 8598 } 8599 8600 for key, value := range shape { 8601 switch key { 8602 case "message": 8603 if value != nil { 8604 jtv, ok := value.(string) 8605 if !ok { 8606 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8607 } 8608 sv.Message = ptr.String(jtv) 8609 } 8610 8611 default: 8612 _, _ = key, value 8613 8614 } 8615 } 8616 *v = sv 8617 return nil 8618} 8619 8620func awsAwsjson11_deserializeDocumentInvalidArnException(v **types.InvalidArnException, value interface{}) error { 8621 if v == nil { 8622 return fmt.Errorf("unexpected nil of type %T", v) 8623 } 8624 if value == nil { 8625 return nil 8626 } 8627 8628 shape, ok := value.(map[string]interface{}) 8629 if !ok { 8630 return fmt.Errorf("unexpected JSON type %v", value) 8631 } 8632 8633 var sv *types.InvalidArnException 8634 if *v == nil { 8635 sv = &types.InvalidArnException{} 8636 } else { 8637 sv = *v 8638 } 8639 8640 for key, value := range shape { 8641 switch key { 8642 case "message": 8643 if value != nil { 8644 jtv, ok := value.(string) 8645 if !ok { 8646 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8647 } 8648 sv.Message = ptr.String(jtv) 8649 } 8650 8651 default: 8652 _, _ = key, value 8653 8654 } 8655 } 8656 *v = sv 8657 return nil 8658} 8659 8660func awsAwsjson11_deserializeDocumentInvalidBlockerDeclarationException(v **types.InvalidBlockerDeclarationException, value interface{}) error { 8661 if v == nil { 8662 return fmt.Errorf("unexpected nil of type %T", v) 8663 } 8664 if value == nil { 8665 return nil 8666 } 8667 8668 shape, ok := value.(map[string]interface{}) 8669 if !ok { 8670 return fmt.Errorf("unexpected JSON type %v", value) 8671 } 8672 8673 var sv *types.InvalidBlockerDeclarationException 8674 if *v == nil { 8675 sv = &types.InvalidBlockerDeclarationException{} 8676 } else { 8677 sv = *v 8678 } 8679 8680 for key, value := range shape { 8681 switch key { 8682 case "message": 8683 if value != nil { 8684 jtv, ok := value.(string) 8685 if !ok { 8686 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8687 } 8688 sv.Message = ptr.String(jtv) 8689 } 8690 8691 default: 8692 _, _ = key, value 8693 8694 } 8695 } 8696 *v = sv 8697 return nil 8698} 8699 8700func awsAwsjson11_deserializeDocumentInvalidClientTokenException(v **types.InvalidClientTokenException, value interface{}) error { 8701 if v == nil { 8702 return fmt.Errorf("unexpected nil of type %T", v) 8703 } 8704 if value == nil { 8705 return nil 8706 } 8707 8708 shape, ok := value.(map[string]interface{}) 8709 if !ok { 8710 return fmt.Errorf("unexpected JSON type %v", value) 8711 } 8712 8713 var sv *types.InvalidClientTokenException 8714 if *v == nil { 8715 sv = &types.InvalidClientTokenException{} 8716 } else { 8717 sv = *v 8718 } 8719 8720 for key, value := range shape { 8721 switch key { 8722 case "message": 8723 if value != nil { 8724 jtv, ok := value.(string) 8725 if !ok { 8726 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8727 } 8728 sv.Message = ptr.String(jtv) 8729 } 8730 8731 default: 8732 _, _ = key, value 8733 8734 } 8735 } 8736 *v = sv 8737 return nil 8738} 8739 8740func awsAwsjson11_deserializeDocumentInvalidJobException(v **types.InvalidJobException, value interface{}) error { 8741 if v == nil { 8742 return fmt.Errorf("unexpected nil of type %T", v) 8743 } 8744 if value == nil { 8745 return nil 8746 } 8747 8748 shape, ok := value.(map[string]interface{}) 8749 if !ok { 8750 return fmt.Errorf("unexpected JSON type %v", value) 8751 } 8752 8753 var sv *types.InvalidJobException 8754 if *v == nil { 8755 sv = &types.InvalidJobException{} 8756 } else { 8757 sv = *v 8758 } 8759 8760 for key, value := range shape { 8761 switch key { 8762 case "message": 8763 if value != nil { 8764 jtv, ok := value.(string) 8765 if !ok { 8766 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8767 } 8768 sv.Message = ptr.String(jtv) 8769 } 8770 8771 default: 8772 _, _ = key, value 8773 8774 } 8775 } 8776 *v = sv 8777 return nil 8778} 8779 8780func awsAwsjson11_deserializeDocumentInvalidJobStateException(v **types.InvalidJobStateException, value interface{}) error { 8781 if v == nil { 8782 return fmt.Errorf("unexpected nil of type %T", v) 8783 } 8784 if value == nil { 8785 return nil 8786 } 8787 8788 shape, ok := value.(map[string]interface{}) 8789 if !ok { 8790 return fmt.Errorf("unexpected JSON type %v", value) 8791 } 8792 8793 var sv *types.InvalidJobStateException 8794 if *v == nil { 8795 sv = &types.InvalidJobStateException{} 8796 } else { 8797 sv = *v 8798 } 8799 8800 for key, value := range shape { 8801 switch key { 8802 case "message": 8803 if value != nil { 8804 jtv, ok := value.(string) 8805 if !ok { 8806 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8807 } 8808 sv.Message = ptr.String(jtv) 8809 } 8810 8811 default: 8812 _, _ = key, value 8813 8814 } 8815 } 8816 *v = sv 8817 return nil 8818} 8819 8820func awsAwsjson11_deserializeDocumentInvalidNextTokenException(v **types.InvalidNextTokenException, value interface{}) error { 8821 if v == nil { 8822 return fmt.Errorf("unexpected nil of type %T", v) 8823 } 8824 if value == nil { 8825 return nil 8826 } 8827 8828 shape, ok := value.(map[string]interface{}) 8829 if !ok { 8830 return fmt.Errorf("unexpected JSON type %v", value) 8831 } 8832 8833 var sv *types.InvalidNextTokenException 8834 if *v == nil { 8835 sv = &types.InvalidNextTokenException{} 8836 } else { 8837 sv = *v 8838 } 8839 8840 for key, value := range shape { 8841 switch key { 8842 case "message": 8843 if value != nil { 8844 jtv, ok := value.(string) 8845 if !ok { 8846 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8847 } 8848 sv.Message = ptr.String(jtv) 8849 } 8850 8851 default: 8852 _, _ = key, value 8853 8854 } 8855 } 8856 *v = sv 8857 return nil 8858} 8859 8860func awsAwsjson11_deserializeDocumentInvalidNonceException(v **types.InvalidNonceException, value interface{}) error { 8861 if v == nil { 8862 return fmt.Errorf("unexpected nil of type %T", v) 8863 } 8864 if value == nil { 8865 return nil 8866 } 8867 8868 shape, ok := value.(map[string]interface{}) 8869 if !ok { 8870 return fmt.Errorf("unexpected JSON type %v", value) 8871 } 8872 8873 var sv *types.InvalidNonceException 8874 if *v == nil { 8875 sv = &types.InvalidNonceException{} 8876 } else { 8877 sv = *v 8878 } 8879 8880 for key, value := range shape { 8881 switch key { 8882 case "message": 8883 if value != nil { 8884 jtv, ok := value.(string) 8885 if !ok { 8886 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8887 } 8888 sv.Message = ptr.String(jtv) 8889 } 8890 8891 default: 8892 _, _ = key, value 8893 8894 } 8895 } 8896 *v = sv 8897 return nil 8898} 8899 8900func awsAwsjson11_deserializeDocumentInvalidStageDeclarationException(v **types.InvalidStageDeclarationException, value interface{}) error { 8901 if v == nil { 8902 return fmt.Errorf("unexpected nil of type %T", v) 8903 } 8904 if value == nil { 8905 return nil 8906 } 8907 8908 shape, ok := value.(map[string]interface{}) 8909 if !ok { 8910 return fmt.Errorf("unexpected JSON type %v", value) 8911 } 8912 8913 var sv *types.InvalidStageDeclarationException 8914 if *v == nil { 8915 sv = &types.InvalidStageDeclarationException{} 8916 } else { 8917 sv = *v 8918 } 8919 8920 for key, value := range shape { 8921 switch key { 8922 case "message": 8923 if value != nil { 8924 jtv, ok := value.(string) 8925 if !ok { 8926 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8927 } 8928 sv.Message = ptr.String(jtv) 8929 } 8930 8931 default: 8932 _, _ = key, value 8933 8934 } 8935 } 8936 *v = sv 8937 return nil 8938} 8939 8940func awsAwsjson11_deserializeDocumentInvalidStructureException(v **types.InvalidStructureException, value interface{}) error { 8941 if v == nil { 8942 return fmt.Errorf("unexpected nil of type %T", v) 8943 } 8944 if value == nil { 8945 return nil 8946 } 8947 8948 shape, ok := value.(map[string]interface{}) 8949 if !ok { 8950 return fmt.Errorf("unexpected JSON type %v", value) 8951 } 8952 8953 var sv *types.InvalidStructureException 8954 if *v == nil { 8955 sv = &types.InvalidStructureException{} 8956 } else { 8957 sv = *v 8958 } 8959 8960 for key, value := range shape { 8961 switch key { 8962 case "message": 8963 if value != nil { 8964 jtv, ok := value.(string) 8965 if !ok { 8966 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8967 } 8968 sv.Message = ptr.String(jtv) 8969 } 8970 8971 default: 8972 _, _ = key, value 8973 8974 } 8975 } 8976 *v = sv 8977 return nil 8978} 8979 8980func awsAwsjson11_deserializeDocumentInvalidTagsException(v **types.InvalidTagsException, value interface{}) error { 8981 if v == nil { 8982 return fmt.Errorf("unexpected nil of type %T", v) 8983 } 8984 if value == nil { 8985 return nil 8986 } 8987 8988 shape, ok := value.(map[string]interface{}) 8989 if !ok { 8990 return fmt.Errorf("unexpected JSON type %v", value) 8991 } 8992 8993 var sv *types.InvalidTagsException 8994 if *v == nil { 8995 sv = &types.InvalidTagsException{} 8996 } else { 8997 sv = *v 8998 } 8999 9000 for key, value := range shape { 9001 switch key { 9002 case "message": 9003 if value != nil { 9004 jtv, ok := value.(string) 9005 if !ok { 9006 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9007 } 9008 sv.Message = ptr.String(jtv) 9009 } 9010 9011 default: 9012 _, _ = key, value 9013 9014 } 9015 } 9016 *v = sv 9017 return nil 9018} 9019 9020func awsAwsjson11_deserializeDocumentInvalidWebhookAuthenticationParametersException(v **types.InvalidWebhookAuthenticationParametersException, value interface{}) error { 9021 if v == nil { 9022 return fmt.Errorf("unexpected nil of type %T", v) 9023 } 9024 if value == nil { 9025 return nil 9026 } 9027 9028 shape, ok := value.(map[string]interface{}) 9029 if !ok { 9030 return fmt.Errorf("unexpected JSON type %v", value) 9031 } 9032 9033 var sv *types.InvalidWebhookAuthenticationParametersException 9034 if *v == nil { 9035 sv = &types.InvalidWebhookAuthenticationParametersException{} 9036 } else { 9037 sv = *v 9038 } 9039 9040 for key, value := range shape { 9041 switch key { 9042 case "message": 9043 if value != nil { 9044 jtv, ok := value.(string) 9045 if !ok { 9046 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9047 } 9048 sv.Message = ptr.String(jtv) 9049 } 9050 9051 default: 9052 _, _ = key, value 9053 9054 } 9055 } 9056 *v = sv 9057 return nil 9058} 9059 9060func awsAwsjson11_deserializeDocumentInvalidWebhookFilterPatternException(v **types.InvalidWebhookFilterPatternException, value interface{}) error { 9061 if v == nil { 9062 return fmt.Errorf("unexpected nil of type %T", v) 9063 } 9064 if value == nil { 9065 return nil 9066 } 9067 9068 shape, ok := value.(map[string]interface{}) 9069 if !ok { 9070 return fmt.Errorf("unexpected JSON type %v", value) 9071 } 9072 9073 var sv *types.InvalidWebhookFilterPatternException 9074 if *v == nil { 9075 sv = &types.InvalidWebhookFilterPatternException{} 9076 } else { 9077 sv = *v 9078 } 9079 9080 for key, value := range shape { 9081 switch key { 9082 case "message": 9083 if value != nil { 9084 jtv, ok := value.(string) 9085 if !ok { 9086 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9087 } 9088 sv.Message = ptr.String(jtv) 9089 } 9090 9091 default: 9092 _, _ = key, value 9093 9094 } 9095 } 9096 *v = sv 9097 return nil 9098} 9099 9100func awsAwsjson11_deserializeDocumentJob(v **types.Job, value interface{}) error { 9101 if v == nil { 9102 return fmt.Errorf("unexpected nil of type %T", v) 9103 } 9104 if value == nil { 9105 return nil 9106 } 9107 9108 shape, ok := value.(map[string]interface{}) 9109 if !ok { 9110 return fmt.Errorf("unexpected JSON type %v", value) 9111 } 9112 9113 var sv *types.Job 9114 if *v == nil { 9115 sv = &types.Job{} 9116 } else { 9117 sv = *v 9118 } 9119 9120 for key, value := range shape { 9121 switch key { 9122 case "accountId": 9123 if value != nil { 9124 jtv, ok := value.(string) 9125 if !ok { 9126 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 9127 } 9128 sv.AccountId = ptr.String(jtv) 9129 } 9130 9131 case "data": 9132 if err := awsAwsjson11_deserializeDocumentJobData(&sv.Data, value); err != nil { 9133 return err 9134 } 9135 9136 case "id": 9137 if value != nil { 9138 jtv, ok := value.(string) 9139 if !ok { 9140 return fmt.Errorf("expected JobId to be of type string, got %T instead", value) 9141 } 9142 sv.Id = ptr.String(jtv) 9143 } 9144 9145 case "nonce": 9146 if value != nil { 9147 jtv, ok := value.(string) 9148 if !ok { 9149 return fmt.Errorf("expected Nonce to be of type string, got %T instead", value) 9150 } 9151 sv.Nonce = ptr.String(jtv) 9152 } 9153 9154 default: 9155 _, _ = key, value 9156 9157 } 9158 } 9159 *v = sv 9160 return nil 9161} 9162 9163func awsAwsjson11_deserializeDocumentJobData(v **types.JobData, value interface{}) error { 9164 if v == nil { 9165 return fmt.Errorf("unexpected nil of type %T", v) 9166 } 9167 if value == nil { 9168 return nil 9169 } 9170 9171 shape, ok := value.(map[string]interface{}) 9172 if !ok { 9173 return fmt.Errorf("unexpected JSON type %v", value) 9174 } 9175 9176 var sv *types.JobData 9177 if *v == nil { 9178 sv = &types.JobData{} 9179 } else { 9180 sv = *v 9181 } 9182 9183 for key, value := range shape { 9184 switch key { 9185 case "actionConfiguration": 9186 if err := awsAwsjson11_deserializeDocumentActionConfiguration(&sv.ActionConfiguration, value); err != nil { 9187 return err 9188 } 9189 9190 case "actionTypeId": 9191 if err := awsAwsjson11_deserializeDocumentActionTypeId(&sv.ActionTypeId, value); err != nil { 9192 return err 9193 } 9194 9195 case "artifactCredentials": 9196 if err := awsAwsjson11_deserializeDocumentAWSSessionCredentials(&sv.ArtifactCredentials, value); err != nil { 9197 return err 9198 } 9199 9200 case "continuationToken": 9201 if value != nil { 9202 jtv, ok := value.(string) 9203 if !ok { 9204 return fmt.Errorf("expected ContinuationToken to be of type string, got %T instead", value) 9205 } 9206 sv.ContinuationToken = ptr.String(jtv) 9207 } 9208 9209 case "encryptionKey": 9210 if err := awsAwsjson11_deserializeDocumentEncryptionKey(&sv.EncryptionKey, value); err != nil { 9211 return err 9212 } 9213 9214 case "inputArtifacts": 9215 if err := awsAwsjson11_deserializeDocumentArtifactList(&sv.InputArtifacts, value); err != nil { 9216 return err 9217 } 9218 9219 case "outputArtifacts": 9220 if err := awsAwsjson11_deserializeDocumentArtifactList(&sv.OutputArtifacts, value); err != nil { 9221 return err 9222 } 9223 9224 case "pipelineContext": 9225 if err := awsAwsjson11_deserializeDocumentPipelineContext(&sv.PipelineContext, value); err != nil { 9226 return err 9227 } 9228 9229 default: 9230 _, _ = key, value 9231 9232 } 9233 } 9234 *v = sv 9235 return nil 9236} 9237 9238func awsAwsjson11_deserializeDocumentJobDetails(v **types.JobDetails, value interface{}) error { 9239 if v == nil { 9240 return fmt.Errorf("unexpected nil of type %T", v) 9241 } 9242 if value == nil { 9243 return nil 9244 } 9245 9246 shape, ok := value.(map[string]interface{}) 9247 if !ok { 9248 return fmt.Errorf("unexpected JSON type %v", value) 9249 } 9250 9251 var sv *types.JobDetails 9252 if *v == nil { 9253 sv = &types.JobDetails{} 9254 } else { 9255 sv = *v 9256 } 9257 9258 for key, value := range shape { 9259 switch key { 9260 case "accountId": 9261 if value != nil { 9262 jtv, ok := value.(string) 9263 if !ok { 9264 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 9265 } 9266 sv.AccountId = ptr.String(jtv) 9267 } 9268 9269 case "data": 9270 if err := awsAwsjson11_deserializeDocumentJobData(&sv.Data, value); err != nil { 9271 return err 9272 } 9273 9274 case "id": 9275 if value != nil { 9276 jtv, ok := value.(string) 9277 if !ok { 9278 return fmt.Errorf("expected JobId to be of type string, got %T instead", value) 9279 } 9280 sv.Id = ptr.String(jtv) 9281 } 9282 9283 default: 9284 _, _ = key, value 9285 9286 } 9287 } 9288 *v = sv 9289 return nil 9290} 9291 9292func awsAwsjson11_deserializeDocumentJobList(v *[]types.Job, value interface{}) error { 9293 if v == nil { 9294 return fmt.Errorf("unexpected nil of type %T", v) 9295 } 9296 if value == nil { 9297 return nil 9298 } 9299 9300 shape, ok := value.([]interface{}) 9301 if !ok { 9302 return fmt.Errorf("unexpected JSON type %v", value) 9303 } 9304 9305 var cv []types.Job 9306 if *v == nil { 9307 cv = []types.Job{} 9308 } else { 9309 cv = *v 9310 } 9311 9312 for _, value := range shape { 9313 var col types.Job 9314 destAddr := &col 9315 if err := awsAwsjson11_deserializeDocumentJob(&destAddr, value); err != nil { 9316 return err 9317 } 9318 col = *destAddr 9319 cv = append(cv, col) 9320 9321 } 9322 *v = cv 9323 return nil 9324} 9325 9326func awsAwsjson11_deserializeDocumentJobNotFoundException(v **types.JobNotFoundException, value interface{}) error { 9327 if v == nil { 9328 return fmt.Errorf("unexpected nil of type %T", v) 9329 } 9330 if value == nil { 9331 return nil 9332 } 9333 9334 shape, ok := value.(map[string]interface{}) 9335 if !ok { 9336 return fmt.Errorf("unexpected JSON type %v", value) 9337 } 9338 9339 var sv *types.JobNotFoundException 9340 if *v == nil { 9341 sv = &types.JobNotFoundException{} 9342 } else { 9343 sv = *v 9344 } 9345 9346 for key, value := range shape { 9347 switch key { 9348 case "message": 9349 if value != nil { 9350 jtv, ok := value.(string) 9351 if !ok { 9352 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9353 } 9354 sv.Message = ptr.String(jtv) 9355 } 9356 9357 default: 9358 _, _ = key, value 9359 9360 } 9361 } 9362 *v = sv 9363 return nil 9364} 9365 9366func awsAwsjson11_deserializeDocumentJobWorkerExecutorConfiguration(v **types.JobWorkerExecutorConfiguration, value interface{}) error { 9367 if v == nil { 9368 return fmt.Errorf("unexpected nil of type %T", v) 9369 } 9370 if value == nil { 9371 return nil 9372 } 9373 9374 shape, ok := value.(map[string]interface{}) 9375 if !ok { 9376 return fmt.Errorf("unexpected JSON type %v", value) 9377 } 9378 9379 var sv *types.JobWorkerExecutorConfiguration 9380 if *v == nil { 9381 sv = &types.JobWorkerExecutorConfiguration{} 9382 } else { 9383 sv = *v 9384 } 9385 9386 for key, value := range shape { 9387 switch key { 9388 case "pollingAccounts": 9389 if err := awsAwsjson11_deserializeDocumentPollingAccountList(&sv.PollingAccounts, value); err != nil { 9390 return err 9391 } 9392 9393 case "pollingServicePrincipals": 9394 if err := awsAwsjson11_deserializeDocumentPollingServicePrincipalList(&sv.PollingServicePrincipals, value); err != nil { 9395 return err 9396 } 9397 9398 default: 9399 _, _ = key, value 9400 9401 } 9402 } 9403 *v = sv 9404 return nil 9405} 9406 9407func awsAwsjson11_deserializeDocumentLambdaExecutorConfiguration(v **types.LambdaExecutorConfiguration, value interface{}) error { 9408 if v == nil { 9409 return fmt.Errorf("unexpected nil of type %T", v) 9410 } 9411 if value == nil { 9412 return nil 9413 } 9414 9415 shape, ok := value.(map[string]interface{}) 9416 if !ok { 9417 return fmt.Errorf("unexpected JSON type %v", value) 9418 } 9419 9420 var sv *types.LambdaExecutorConfiguration 9421 if *v == nil { 9422 sv = &types.LambdaExecutorConfiguration{} 9423 } else { 9424 sv = *v 9425 } 9426 9427 for key, value := range shape { 9428 switch key { 9429 case "lambdaFunctionArn": 9430 if value != nil { 9431 jtv, ok := value.(string) 9432 if !ok { 9433 return fmt.Errorf("expected LambdaFunctionArn to be of type string, got %T instead", value) 9434 } 9435 sv.LambdaFunctionArn = ptr.String(jtv) 9436 } 9437 9438 default: 9439 _, _ = key, value 9440 9441 } 9442 } 9443 *v = sv 9444 return nil 9445} 9446 9447func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { 9448 if v == nil { 9449 return fmt.Errorf("unexpected nil of type %T", v) 9450 } 9451 if value == nil { 9452 return nil 9453 } 9454 9455 shape, ok := value.(map[string]interface{}) 9456 if !ok { 9457 return fmt.Errorf("unexpected JSON type %v", value) 9458 } 9459 9460 var sv *types.LimitExceededException 9461 if *v == nil { 9462 sv = &types.LimitExceededException{} 9463 } else { 9464 sv = *v 9465 } 9466 9467 for key, value := range shape { 9468 switch key { 9469 case "message": 9470 if value != nil { 9471 jtv, ok := value.(string) 9472 if !ok { 9473 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9474 } 9475 sv.Message = ptr.String(jtv) 9476 } 9477 9478 default: 9479 _, _ = key, value 9480 9481 } 9482 } 9483 *v = sv 9484 return nil 9485} 9486 9487func awsAwsjson11_deserializeDocumentListWebhookItem(v **types.ListWebhookItem, value interface{}) error { 9488 if v == nil { 9489 return fmt.Errorf("unexpected nil of type %T", v) 9490 } 9491 if value == nil { 9492 return nil 9493 } 9494 9495 shape, ok := value.(map[string]interface{}) 9496 if !ok { 9497 return fmt.Errorf("unexpected JSON type %v", value) 9498 } 9499 9500 var sv *types.ListWebhookItem 9501 if *v == nil { 9502 sv = &types.ListWebhookItem{} 9503 } else { 9504 sv = *v 9505 } 9506 9507 for key, value := range shape { 9508 switch key { 9509 case "arn": 9510 if value != nil { 9511 jtv, ok := value.(string) 9512 if !ok { 9513 return fmt.Errorf("expected WebhookArn to be of type string, got %T instead", value) 9514 } 9515 sv.Arn = ptr.String(jtv) 9516 } 9517 9518 case "definition": 9519 if err := awsAwsjson11_deserializeDocumentWebhookDefinition(&sv.Definition, value); err != nil { 9520 return err 9521 } 9522 9523 case "errorCode": 9524 if value != nil { 9525 jtv, ok := value.(string) 9526 if !ok { 9527 return fmt.Errorf("expected WebhookErrorCode to be of type string, got %T instead", value) 9528 } 9529 sv.ErrorCode = ptr.String(jtv) 9530 } 9531 9532 case "errorMessage": 9533 if value != nil { 9534 jtv, ok := value.(string) 9535 if !ok { 9536 return fmt.Errorf("expected WebhookErrorMessage to be of type string, got %T instead", value) 9537 } 9538 sv.ErrorMessage = ptr.String(jtv) 9539 } 9540 9541 case "lastTriggered": 9542 if value != nil { 9543 jtv, ok := value.(json.Number) 9544 if !ok { 9545 return fmt.Errorf("expected WebhookLastTriggered to be json.Number, got %T instead", value) 9546 } 9547 f64, err := jtv.Float64() 9548 if err != nil { 9549 return err 9550 } 9551 sv.LastTriggered = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9552 } 9553 9554 case "tags": 9555 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil { 9556 return err 9557 } 9558 9559 case "url": 9560 if value != nil { 9561 jtv, ok := value.(string) 9562 if !ok { 9563 return fmt.Errorf("expected WebhookUrl to be of type string, got %T instead", value) 9564 } 9565 sv.Url = ptr.String(jtv) 9566 } 9567 9568 default: 9569 _, _ = key, value 9570 9571 } 9572 } 9573 *v = sv 9574 return nil 9575} 9576 9577func awsAwsjson11_deserializeDocumentNotLatestPipelineExecutionException(v **types.NotLatestPipelineExecutionException, value interface{}) error { 9578 if v == nil { 9579 return fmt.Errorf("unexpected nil of type %T", v) 9580 } 9581 if value == nil { 9582 return nil 9583 } 9584 9585 shape, ok := value.(map[string]interface{}) 9586 if !ok { 9587 return fmt.Errorf("unexpected JSON type %v", value) 9588 } 9589 9590 var sv *types.NotLatestPipelineExecutionException 9591 if *v == nil { 9592 sv = &types.NotLatestPipelineExecutionException{} 9593 } else { 9594 sv = *v 9595 } 9596 9597 for key, value := range shape { 9598 switch key { 9599 case "message": 9600 if value != nil { 9601 jtv, ok := value.(string) 9602 if !ok { 9603 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9604 } 9605 sv.Message = ptr.String(jtv) 9606 } 9607 9608 default: 9609 _, _ = key, value 9610 9611 } 9612 } 9613 *v = sv 9614 return nil 9615} 9616 9617func awsAwsjson11_deserializeDocumentOutputArtifact(v **types.OutputArtifact, value interface{}) error { 9618 if v == nil { 9619 return fmt.Errorf("unexpected nil of type %T", v) 9620 } 9621 if value == nil { 9622 return nil 9623 } 9624 9625 shape, ok := value.(map[string]interface{}) 9626 if !ok { 9627 return fmt.Errorf("unexpected JSON type %v", value) 9628 } 9629 9630 var sv *types.OutputArtifact 9631 if *v == nil { 9632 sv = &types.OutputArtifact{} 9633 } else { 9634 sv = *v 9635 } 9636 9637 for key, value := range shape { 9638 switch key { 9639 case "name": 9640 if value != nil { 9641 jtv, ok := value.(string) 9642 if !ok { 9643 return fmt.Errorf("expected ArtifactName to be of type string, got %T instead", value) 9644 } 9645 sv.Name = ptr.String(jtv) 9646 } 9647 9648 default: 9649 _, _ = key, value 9650 9651 } 9652 } 9653 *v = sv 9654 return nil 9655} 9656 9657func awsAwsjson11_deserializeDocumentOutputArtifactList(v *[]types.OutputArtifact, value interface{}) error { 9658 if v == nil { 9659 return fmt.Errorf("unexpected nil of type %T", v) 9660 } 9661 if value == nil { 9662 return nil 9663 } 9664 9665 shape, ok := value.([]interface{}) 9666 if !ok { 9667 return fmt.Errorf("unexpected JSON type %v", value) 9668 } 9669 9670 var cv []types.OutputArtifact 9671 if *v == nil { 9672 cv = []types.OutputArtifact{} 9673 } else { 9674 cv = *v 9675 } 9676 9677 for _, value := range shape { 9678 var col types.OutputArtifact 9679 destAddr := &col 9680 if err := awsAwsjson11_deserializeDocumentOutputArtifact(&destAddr, value); err != nil { 9681 return err 9682 } 9683 col = *destAddr 9684 cv = append(cv, col) 9685 9686 } 9687 *v = cv 9688 return nil 9689} 9690 9691func awsAwsjson11_deserializeDocumentOutputVariablesMap(v *map[string]string, value interface{}) error { 9692 if v == nil { 9693 return fmt.Errorf("unexpected nil of type %T", v) 9694 } 9695 if value == nil { 9696 return nil 9697 } 9698 9699 shape, ok := value.(map[string]interface{}) 9700 if !ok { 9701 return fmt.Errorf("unexpected JSON type %v", value) 9702 } 9703 9704 var mv map[string]string 9705 if *v == nil { 9706 mv = map[string]string{} 9707 } else { 9708 mv = *v 9709 } 9710 9711 for key, value := range shape { 9712 var parsedVal string 9713 if value != nil { 9714 jtv, ok := value.(string) 9715 if !ok { 9716 return fmt.Errorf("expected OutputVariablesValue to be of type string, got %T instead", value) 9717 } 9718 parsedVal = jtv 9719 } 9720 mv[key] = parsedVal 9721 9722 } 9723 *v = mv 9724 return nil 9725} 9726 9727func awsAwsjson11_deserializeDocumentOutputVariablesSizeExceededException(v **types.OutputVariablesSizeExceededException, value interface{}) error { 9728 if v == nil { 9729 return fmt.Errorf("unexpected nil of type %T", v) 9730 } 9731 if value == nil { 9732 return nil 9733 } 9734 9735 shape, ok := value.(map[string]interface{}) 9736 if !ok { 9737 return fmt.Errorf("unexpected JSON type %v", value) 9738 } 9739 9740 var sv *types.OutputVariablesSizeExceededException 9741 if *v == nil { 9742 sv = &types.OutputVariablesSizeExceededException{} 9743 } else { 9744 sv = *v 9745 } 9746 9747 for key, value := range shape { 9748 switch key { 9749 case "message": 9750 if value != nil { 9751 jtv, ok := value.(string) 9752 if !ok { 9753 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9754 } 9755 sv.Message = ptr.String(jtv) 9756 } 9757 9758 default: 9759 _, _ = key, value 9760 9761 } 9762 } 9763 *v = sv 9764 return nil 9765} 9766 9767func awsAwsjson11_deserializeDocumentPipelineContext(v **types.PipelineContext, value interface{}) error { 9768 if v == nil { 9769 return fmt.Errorf("unexpected nil of type %T", v) 9770 } 9771 if value == nil { 9772 return nil 9773 } 9774 9775 shape, ok := value.(map[string]interface{}) 9776 if !ok { 9777 return fmt.Errorf("unexpected JSON type %v", value) 9778 } 9779 9780 var sv *types.PipelineContext 9781 if *v == nil { 9782 sv = &types.PipelineContext{} 9783 } else { 9784 sv = *v 9785 } 9786 9787 for key, value := range shape { 9788 switch key { 9789 case "action": 9790 if err := awsAwsjson11_deserializeDocumentActionContext(&sv.Action, value); err != nil { 9791 return err 9792 } 9793 9794 case "pipelineArn": 9795 if value != nil { 9796 jtv, ok := value.(string) 9797 if !ok { 9798 return fmt.Errorf("expected PipelineArn to be of type string, got %T instead", value) 9799 } 9800 sv.PipelineArn = ptr.String(jtv) 9801 } 9802 9803 case "pipelineExecutionId": 9804 if value != nil { 9805 jtv, ok := value.(string) 9806 if !ok { 9807 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 9808 } 9809 sv.PipelineExecutionId = ptr.String(jtv) 9810 } 9811 9812 case "pipelineName": 9813 if value != nil { 9814 jtv, ok := value.(string) 9815 if !ok { 9816 return fmt.Errorf("expected PipelineName to be of type string, got %T instead", value) 9817 } 9818 sv.PipelineName = ptr.String(jtv) 9819 } 9820 9821 case "stage": 9822 if err := awsAwsjson11_deserializeDocumentStageContext(&sv.Stage, value); err != nil { 9823 return err 9824 } 9825 9826 default: 9827 _, _ = key, value 9828 9829 } 9830 } 9831 *v = sv 9832 return nil 9833} 9834 9835func awsAwsjson11_deserializeDocumentPipelineDeclaration(v **types.PipelineDeclaration, value interface{}) error { 9836 if v == nil { 9837 return fmt.Errorf("unexpected nil of type %T", v) 9838 } 9839 if value == nil { 9840 return nil 9841 } 9842 9843 shape, ok := value.(map[string]interface{}) 9844 if !ok { 9845 return fmt.Errorf("unexpected JSON type %v", value) 9846 } 9847 9848 var sv *types.PipelineDeclaration 9849 if *v == nil { 9850 sv = &types.PipelineDeclaration{} 9851 } else { 9852 sv = *v 9853 } 9854 9855 for key, value := range shape { 9856 switch key { 9857 case "artifactStore": 9858 if err := awsAwsjson11_deserializeDocumentArtifactStore(&sv.ArtifactStore, value); err != nil { 9859 return err 9860 } 9861 9862 case "artifactStores": 9863 if err := awsAwsjson11_deserializeDocumentArtifactStoreMap(&sv.ArtifactStores, value); err != nil { 9864 return err 9865 } 9866 9867 case "name": 9868 if value != nil { 9869 jtv, ok := value.(string) 9870 if !ok { 9871 return fmt.Errorf("expected PipelineName to be of type string, got %T instead", value) 9872 } 9873 sv.Name = ptr.String(jtv) 9874 } 9875 9876 case "roleArn": 9877 if value != nil { 9878 jtv, ok := value.(string) 9879 if !ok { 9880 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 9881 } 9882 sv.RoleArn = ptr.String(jtv) 9883 } 9884 9885 case "stages": 9886 if err := awsAwsjson11_deserializeDocumentPipelineStageDeclarationList(&sv.Stages, value); err != nil { 9887 return err 9888 } 9889 9890 case "version": 9891 if value != nil { 9892 jtv, ok := value.(json.Number) 9893 if !ok { 9894 return fmt.Errorf("expected PipelineVersion to be json.Number, got %T instead", value) 9895 } 9896 i64, err := jtv.Int64() 9897 if err != nil { 9898 return err 9899 } 9900 sv.Version = ptr.Int32(int32(i64)) 9901 } 9902 9903 default: 9904 _, _ = key, value 9905 9906 } 9907 } 9908 *v = sv 9909 return nil 9910} 9911 9912func awsAwsjson11_deserializeDocumentPipelineExecution(v **types.PipelineExecution, value interface{}) error { 9913 if v == nil { 9914 return fmt.Errorf("unexpected nil of type %T", v) 9915 } 9916 if value == nil { 9917 return nil 9918 } 9919 9920 shape, ok := value.(map[string]interface{}) 9921 if !ok { 9922 return fmt.Errorf("unexpected JSON type %v", value) 9923 } 9924 9925 var sv *types.PipelineExecution 9926 if *v == nil { 9927 sv = &types.PipelineExecution{} 9928 } else { 9929 sv = *v 9930 } 9931 9932 for key, value := range shape { 9933 switch key { 9934 case "artifactRevisions": 9935 if err := awsAwsjson11_deserializeDocumentArtifactRevisionList(&sv.ArtifactRevisions, value); err != nil { 9936 return err 9937 } 9938 9939 case "pipelineExecutionId": 9940 if value != nil { 9941 jtv, ok := value.(string) 9942 if !ok { 9943 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 9944 } 9945 sv.PipelineExecutionId = ptr.String(jtv) 9946 } 9947 9948 case "pipelineName": 9949 if value != nil { 9950 jtv, ok := value.(string) 9951 if !ok { 9952 return fmt.Errorf("expected PipelineName to be of type string, got %T instead", value) 9953 } 9954 sv.PipelineName = ptr.String(jtv) 9955 } 9956 9957 case "pipelineVersion": 9958 if value != nil { 9959 jtv, ok := value.(json.Number) 9960 if !ok { 9961 return fmt.Errorf("expected PipelineVersion to be json.Number, got %T instead", value) 9962 } 9963 i64, err := jtv.Int64() 9964 if err != nil { 9965 return err 9966 } 9967 sv.PipelineVersion = ptr.Int32(int32(i64)) 9968 } 9969 9970 case "status": 9971 if value != nil { 9972 jtv, ok := value.(string) 9973 if !ok { 9974 return fmt.Errorf("expected PipelineExecutionStatus to be of type string, got %T instead", value) 9975 } 9976 sv.Status = types.PipelineExecutionStatus(jtv) 9977 } 9978 9979 case "statusSummary": 9980 if value != nil { 9981 jtv, ok := value.(string) 9982 if !ok { 9983 return fmt.Errorf("expected PipelineExecutionStatusSummary to be of type string, got %T instead", value) 9984 } 9985 sv.StatusSummary = ptr.String(jtv) 9986 } 9987 9988 default: 9989 _, _ = key, value 9990 9991 } 9992 } 9993 *v = sv 9994 return nil 9995} 9996 9997func awsAwsjson11_deserializeDocumentPipelineExecutionNotFoundException(v **types.PipelineExecutionNotFoundException, value interface{}) error { 9998 if v == nil { 9999 return fmt.Errorf("unexpected nil of type %T", v) 10000 } 10001 if value == nil { 10002 return nil 10003 } 10004 10005 shape, ok := value.(map[string]interface{}) 10006 if !ok { 10007 return fmt.Errorf("unexpected JSON type %v", value) 10008 } 10009 10010 var sv *types.PipelineExecutionNotFoundException 10011 if *v == nil { 10012 sv = &types.PipelineExecutionNotFoundException{} 10013 } else { 10014 sv = *v 10015 } 10016 10017 for key, value := range shape { 10018 switch key { 10019 case "message": 10020 if value != nil { 10021 jtv, ok := value.(string) 10022 if !ok { 10023 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 10024 } 10025 sv.Message = ptr.String(jtv) 10026 } 10027 10028 default: 10029 _, _ = key, value 10030 10031 } 10032 } 10033 *v = sv 10034 return nil 10035} 10036 10037func awsAwsjson11_deserializeDocumentPipelineExecutionNotStoppableException(v **types.PipelineExecutionNotStoppableException, value interface{}) error { 10038 if v == nil { 10039 return fmt.Errorf("unexpected nil of type %T", v) 10040 } 10041 if value == nil { 10042 return nil 10043 } 10044 10045 shape, ok := value.(map[string]interface{}) 10046 if !ok { 10047 return fmt.Errorf("unexpected JSON type %v", value) 10048 } 10049 10050 var sv *types.PipelineExecutionNotStoppableException 10051 if *v == nil { 10052 sv = &types.PipelineExecutionNotStoppableException{} 10053 } else { 10054 sv = *v 10055 } 10056 10057 for key, value := range shape { 10058 switch key { 10059 case "message": 10060 if value != nil { 10061 jtv, ok := value.(string) 10062 if !ok { 10063 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 10064 } 10065 sv.Message = ptr.String(jtv) 10066 } 10067 10068 default: 10069 _, _ = key, value 10070 10071 } 10072 } 10073 *v = sv 10074 return nil 10075} 10076 10077func awsAwsjson11_deserializeDocumentPipelineExecutionSummary(v **types.PipelineExecutionSummary, value interface{}) error { 10078 if v == nil { 10079 return fmt.Errorf("unexpected nil of type %T", v) 10080 } 10081 if value == nil { 10082 return nil 10083 } 10084 10085 shape, ok := value.(map[string]interface{}) 10086 if !ok { 10087 return fmt.Errorf("unexpected JSON type %v", value) 10088 } 10089 10090 var sv *types.PipelineExecutionSummary 10091 if *v == nil { 10092 sv = &types.PipelineExecutionSummary{} 10093 } else { 10094 sv = *v 10095 } 10096 10097 for key, value := range shape { 10098 switch key { 10099 case "lastUpdateTime": 10100 if value != nil { 10101 jtv, ok := value.(json.Number) 10102 if !ok { 10103 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 10104 } 10105 f64, err := jtv.Float64() 10106 if err != nil { 10107 return err 10108 } 10109 sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10110 } 10111 10112 case "pipelineExecutionId": 10113 if value != nil { 10114 jtv, ok := value.(string) 10115 if !ok { 10116 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 10117 } 10118 sv.PipelineExecutionId = ptr.String(jtv) 10119 } 10120 10121 case "sourceRevisions": 10122 if err := awsAwsjson11_deserializeDocumentSourceRevisionList(&sv.SourceRevisions, value); err != nil { 10123 return err 10124 } 10125 10126 case "startTime": 10127 if value != nil { 10128 jtv, ok := value.(json.Number) 10129 if !ok { 10130 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 10131 } 10132 f64, err := jtv.Float64() 10133 if err != nil { 10134 return err 10135 } 10136 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10137 } 10138 10139 case "status": 10140 if value != nil { 10141 jtv, ok := value.(string) 10142 if !ok { 10143 return fmt.Errorf("expected PipelineExecutionStatus to be of type string, got %T instead", value) 10144 } 10145 sv.Status = types.PipelineExecutionStatus(jtv) 10146 } 10147 10148 case "stopTrigger": 10149 if err := awsAwsjson11_deserializeDocumentStopExecutionTrigger(&sv.StopTrigger, value); err != nil { 10150 return err 10151 } 10152 10153 case "trigger": 10154 if err := awsAwsjson11_deserializeDocumentExecutionTrigger(&sv.Trigger, value); err != nil { 10155 return err 10156 } 10157 10158 default: 10159 _, _ = key, value 10160 10161 } 10162 } 10163 *v = sv 10164 return nil 10165} 10166 10167func awsAwsjson11_deserializeDocumentPipelineExecutionSummaryList(v *[]types.PipelineExecutionSummary, value interface{}) error { 10168 if v == nil { 10169 return fmt.Errorf("unexpected nil of type %T", v) 10170 } 10171 if value == nil { 10172 return nil 10173 } 10174 10175 shape, ok := value.([]interface{}) 10176 if !ok { 10177 return fmt.Errorf("unexpected JSON type %v", value) 10178 } 10179 10180 var cv []types.PipelineExecutionSummary 10181 if *v == nil { 10182 cv = []types.PipelineExecutionSummary{} 10183 } else { 10184 cv = *v 10185 } 10186 10187 for _, value := range shape { 10188 var col types.PipelineExecutionSummary 10189 destAddr := &col 10190 if err := awsAwsjson11_deserializeDocumentPipelineExecutionSummary(&destAddr, value); err != nil { 10191 return err 10192 } 10193 col = *destAddr 10194 cv = append(cv, col) 10195 10196 } 10197 *v = cv 10198 return nil 10199} 10200 10201func awsAwsjson11_deserializeDocumentPipelineList(v *[]types.PipelineSummary, value interface{}) error { 10202 if v == nil { 10203 return fmt.Errorf("unexpected nil of type %T", v) 10204 } 10205 if value == nil { 10206 return nil 10207 } 10208 10209 shape, ok := value.([]interface{}) 10210 if !ok { 10211 return fmt.Errorf("unexpected JSON type %v", value) 10212 } 10213 10214 var cv []types.PipelineSummary 10215 if *v == nil { 10216 cv = []types.PipelineSummary{} 10217 } else { 10218 cv = *v 10219 } 10220 10221 for _, value := range shape { 10222 var col types.PipelineSummary 10223 destAddr := &col 10224 if err := awsAwsjson11_deserializeDocumentPipelineSummary(&destAddr, value); err != nil { 10225 return err 10226 } 10227 col = *destAddr 10228 cv = append(cv, col) 10229 10230 } 10231 *v = cv 10232 return nil 10233} 10234 10235func awsAwsjson11_deserializeDocumentPipelineMetadata(v **types.PipelineMetadata, value interface{}) error { 10236 if v == nil { 10237 return fmt.Errorf("unexpected nil of type %T", v) 10238 } 10239 if value == nil { 10240 return nil 10241 } 10242 10243 shape, ok := value.(map[string]interface{}) 10244 if !ok { 10245 return fmt.Errorf("unexpected JSON type %v", value) 10246 } 10247 10248 var sv *types.PipelineMetadata 10249 if *v == nil { 10250 sv = &types.PipelineMetadata{} 10251 } else { 10252 sv = *v 10253 } 10254 10255 for key, value := range shape { 10256 switch key { 10257 case "created": 10258 if value != nil { 10259 jtv, ok := value.(json.Number) 10260 if !ok { 10261 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 10262 } 10263 f64, err := jtv.Float64() 10264 if err != nil { 10265 return err 10266 } 10267 sv.Created = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10268 } 10269 10270 case "pipelineArn": 10271 if value != nil { 10272 jtv, ok := value.(string) 10273 if !ok { 10274 return fmt.Errorf("expected PipelineArn to be of type string, got %T instead", value) 10275 } 10276 sv.PipelineArn = ptr.String(jtv) 10277 } 10278 10279 case "updated": 10280 if value != nil { 10281 jtv, ok := value.(json.Number) 10282 if !ok { 10283 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 10284 } 10285 f64, err := jtv.Float64() 10286 if err != nil { 10287 return err 10288 } 10289 sv.Updated = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10290 } 10291 10292 default: 10293 _, _ = key, value 10294 10295 } 10296 } 10297 *v = sv 10298 return nil 10299} 10300 10301func awsAwsjson11_deserializeDocumentPipelineNameInUseException(v **types.PipelineNameInUseException, value interface{}) error { 10302 if v == nil { 10303 return fmt.Errorf("unexpected nil of type %T", v) 10304 } 10305 if value == nil { 10306 return nil 10307 } 10308 10309 shape, ok := value.(map[string]interface{}) 10310 if !ok { 10311 return fmt.Errorf("unexpected JSON type %v", value) 10312 } 10313 10314 var sv *types.PipelineNameInUseException 10315 if *v == nil { 10316 sv = &types.PipelineNameInUseException{} 10317 } else { 10318 sv = *v 10319 } 10320 10321 for key, value := range shape { 10322 switch key { 10323 case "message": 10324 if value != nil { 10325 jtv, ok := value.(string) 10326 if !ok { 10327 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 10328 } 10329 sv.Message = ptr.String(jtv) 10330 } 10331 10332 default: 10333 _, _ = key, value 10334 10335 } 10336 } 10337 *v = sv 10338 return nil 10339} 10340 10341func awsAwsjson11_deserializeDocumentPipelineNotFoundException(v **types.PipelineNotFoundException, value interface{}) error { 10342 if v == nil { 10343 return fmt.Errorf("unexpected nil of type %T", v) 10344 } 10345 if value == nil { 10346 return nil 10347 } 10348 10349 shape, ok := value.(map[string]interface{}) 10350 if !ok { 10351 return fmt.Errorf("unexpected JSON type %v", value) 10352 } 10353 10354 var sv *types.PipelineNotFoundException 10355 if *v == nil { 10356 sv = &types.PipelineNotFoundException{} 10357 } else { 10358 sv = *v 10359 } 10360 10361 for key, value := range shape { 10362 switch key { 10363 case "message": 10364 if value != nil { 10365 jtv, ok := value.(string) 10366 if !ok { 10367 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 10368 } 10369 sv.Message = ptr.String(jtv) 10370 } 10371 10372 default: 10373 _, _ = key, value 10374 10375 } 10376 } 10377 *v = sv 10378 return nil 10379} 10380 10381func awsAwsjson11_deserializeDocumentPipelineStageDeclarationList(v *[]types.StageDeclaration, value interface{}) error { 10382 if v == nil { 10383 return fmt.Errorf("unexpected nil of type %T", v) 10384 } 10385 if value == nil { 10386 return nil 10387 } 10388 10389 shape, ok := value.([]interface{}) 10390 if !ok { 10391 return fmt.Errorf("unexpected JSON type %v", value) 10392 } 10393 10394 var cv []types.StageDeclaration 10395 if *v == nil { 10396 cv = []types.StageDeclaration{} 10397 } else { 10398 cv = *v 10399 } 10400 10401 for _, value := range shape { 10402 var col types.StageDeclaration 10403 destAddr := &col 10404 if err := awsAwsjson11_deserializeDocumentStageDeclaration(&destAddr, value); err != nil { 10405 return err 10406 } 10407 col = *destAddr 10408 cv = append(cv, col) 10409 10410 } 10411 *v = cv 10412 return nil 10413} 10414 10415func awsAwsjson11_deserializeDocumentPipelineSummary(v **types.PipelineSummary, value interface{}) error { 10416 if v == nil { 10417 return fmt.Errorf("unexpected nil of type %T", v) 10418 } 10419 if value == nil { 10420 return nil 10421 } 10422 10423 shape, ok := value.(map[string]interface{}) 10424 if !ok { 10425 return fmt.Errorf("unexpected JSON type %v", value) 10426 } 10427 10428 var sv *types.PipelineSummary 10429 if *v == nil { 10430 sv = &types.PipelineSummary{} 10431 } else { 10432 sv = *v 10433 } 10434 10435 for key, value := range shape { 10436 switch key { 10437 case "created": 10438 if value != nil { 10439 jtv, ok := value.(json.Number) 10440 if !ok { 10441 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 10442 } 10443 f64, err := jtv.Float64() 10444 if err != nil { 10445 return err 10446 } 10447 sv.Created = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10448 } 10449 10450 case "name": 10451 if value != nil { 10452 jtv, ok := value.(string) 10453 if !ok { 10454 return fmt.Errorf("expected PipelineName to be of type string, got %T instead", value) 10455 } 10456 sv.Name = ptr.String(jtv) 10457 } 10458 10459 case "updated": 10460 if value != nil { 10461 jtv, ok := value.(json.Number) 10462 if !ok { 10463 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 10464 } 10465 f64, err := jtv.Float64() 10466 if err != nil { 10467 return err 10468 } 10469 sv.Updated = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10470 } 10471 10472 case "version": 10473 if value != nil { 10474 jtv, ok := value.(json.Number) 10475 if !ok { 10476 return fmt.Errorf("expected PipelineVersion to be json.Number, got %T instead", value) 10477 } 10478 i64, err := jtv.Int64() 10479 if err != nil { 10480 return err 10481 } 10482 sv.Version = ptr.Int32(int32(i64)) 10483 } 10484 10485 default: 10486 _, _ = key, value 10487 10488 } 10489 } 10490 *v = sv 10491 return nil 10492} 10493 10494func awsAwsjson11_deserializeDocumentPipelineVersionNotFoundException(v **types.PipelineVersionNotFoundException, value interface{}) error { 10495 if v == nil { 10496 return fmt.Errorf("unexpected nil of type %T", v) 10497 } 10498 if value == nil { 10499 return nil 10500 } 10501 10502 shape, ok := value.(map[string]interface{}) 10503 if !ok { 10504 return fmt.Errorf("unexpected JSON type %v", value) 10505 } 10506 10507 var sv *types.PipelineVersionNotFoundException 10508 if *v == nil { 10509 sv = &types.PipelineVersionNotFoundException{} 10510 } else { 10511 sv = *v 10512 } 10513 10514 for key, value := range shape { 10515 switch key { 10516 case "message": 10517 if value != nil { 10518 jtv, ok := value.(string) 10519 if !ok { 10520 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 10521 } 10522 sv.Message = ptr.String(jtv) 10523 } 10524 10525 default: 10526 _, _ = key, value 10527 10528 } 10529 } 10530 *v = sv 10531 return nil 10532} 10533 10534func awsAwsjson11_deserializeDocumentPollingAccountList(v *[]string, value interface{}) error { 10535 if v == nil { 10536 return fmt.Errorf("unexpected nil of type %T", v) 10537 } 10538 if value == nil { 10539 return nil 10540 } 10541 10542 shape, ok := value.([]interface{}) 10543 if !ok { 10544 return fmt.Errorf("unexpected JSON type %v", value) 10545 } 10546 10547 var cv []string 10548 if *v == nil { 10549 cv = []string{} 10550 } else { 10551 cv = *v 10552 } 10553 10554 for _, value := range shape { 10555 var col string 10556 if value != nil { 10557 jtv, ok := value.(string) 10558 if !ok { 10559 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 10560 } 10561 col = jtv 10562 } 10563 cv = append(cv, col) 10564 10565 } 10566 *v = cv 10567 return nil 10568} 10569 10570func awsAwsjson11_deserializeDocumentPollingServicePrincipalList(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 ServicePrincipal 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_deserializeDocumentRequestFailedException(v **types.RequestFailedException, 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.(map[string]interface{}) 10615 if !ok { 10616 return fmt.Errorf("unexpected JSON type %v", value) 10617 } 10618 10619 var sv *types.RequestFailedException 10620 if *v == nil { 10621 sv = &types.RequestFailedException{} 10622 } else { 10623 sv = *v 10624 } 10625 10626 for key, value := range shape { 10627 switch key { 10628 case "message": 10629 if value != nil { 10630 jtv, ok := value.(string) 10631 if !ok { 10632 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 10633 } 10634 sv.Message = ptr.String(jtv) 10635 } 10636 10637 default: 10638 _, _ = key, value 10639 10640 } 10641 } 10642 *v = sv 10643 return nil 10644} 10645 10646func awsAwsjson11_deserializeDocumentResolvedActionConfigurationMap(v *map[string]string, value interface{}) error { 10647 if v == nil { 10648 return fmt.Errorf("unexpected nil of type %T", v) 10649 } 10650 if value == nil { 10651 return nil 10652 } 10653 10654 shape, ok := value.(map[string]interface{}) 10655 if !ok { 10656 return fmt.Errorf("unexpected JSON type %v", value) 10657 } 10658 10659 var mv map[string]string 10660 if *v == nil { 10661 mv = map[string]string{} 10662 } else { 10663 mv = *v 10664 } 10665 10666 for key, value := range shape { 10667 var parsedVal string 10668 if value != nil { 10669 jtv, ok := value.(string) 10670 if !ok { 10671 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10672 } 10673 parsedVal = jtv 10674 } 10675 mv[key] = parsedVal 10676 10677 } 10678 *v = mv 10679 return nil 10680} 10681 10682func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, 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 sv *types.ResourceNotFoundException 10696 if *v == nil { 10697 sv = &types.ResourceNotFoundException{} 10698 } else { 10699 sv = *v 10700 } 10701 10702 for key, value := range shape { 10703 switch key { 10704 case "message": 10705 if value != nil { 10706 jtv, ok := value.(string) 10707 if !ok { 10708 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 10709 } 10710 sv.Message = ptr.String(jtv) 10711 } 10712 10713 default: 10714 _, _ = key, value 10715 10716 } 10717 } 10718 *v = sv 10719 return nil 10720} 10721 10722func awsAwsjson11_deserializeDocumentS3ArtifactLocation(v **types.S3ArtifactLocation, value interface{}) error { 10723 if v == nil { 10724 return fmt.Errorf("unexpected nil of type %T", v) 10725 } 10726 if value == nil { 10727 return nil 10728 } 10729 10730 shape, ok := value.(map[string]interface{}) 10731 if !ok { 10732 return fmt.Errorf("unexpected JSON type %v", value) 10733 } 10734 10735 var sv *types.S3ArtifactLocation 10736 if *v == nil { 10737 sv = &types.S3ArtifactLocation{} 10738 } else { 10739 sv = *v 10740 } 10741 10742 for key, value := range shape { 10743 switch key { 10744 case "bucketName": 10745 if value != nil { 10746 jtv, ok := value.(string) 10747 if !ok { 10748 return fmt.Errorf("expected S3BucketName to be of type string, got %T instead", value) 10749 } 10750 sv.BucketName = ptr.String(jtv) 10751 } 10752 10753 case "objectKey": 10754 if value != nil { 10755 jtv, ok := value.(string) 10756 if !ok { 10757 return fmt.Errorf("expected S3ObjectKey to be of type string, got %T instead", value) 10758 } 10759 sv.ObjectKey = ptr.String(jtv) 10760 } 10761 10762 default: 10763 _, _ = key, value 10764 10765 } 10766 } 10767 *v = sv 10768 return nil 10769} 10770 10771func awsAwsjson11_deserializeDocumentS3Location(v **types.S3Location, value interface{}) error { 10772 if v == nil { 10773 return fmt.Errorf("unexpected nil of type %T", v) 10774 } 10775 if value == nil { 10776 return nil 10777 } 10778 10779 shape, ok := value.(map[string]interface{}) 10780 if !ok { 10781 return fmt.Errorf("unexpected JSON type %v", value) 10782 } 10783 10784 var sv *types.S3Location 10785 if *v == nil { 10786 sv = &types.S3Location{} 10787 } else { 10788 sv = *v 10789 } 10790 10791 for key, value := range shape { 10792 switch key { 10793 case "bucket": 10794 if value != nil { 10795 jtv, ok := value.(string) 10796 if !ok { 10797 return fmt.Errorf("expected S3Bucket to be of type string, got %T instead", value) 10798 } 10799 sv.Bucket = ptr.String(jtv) 10800 } 10801 10802 case "key": 10803 if value != nil { 10804 jtv, ok := value.(string) 10805 if !ok { 10806 return fmt.Errorf("expected S3Key to be of type string, got %T instead", value) 10807 } 10808 sv.Key = ptr.String(jtv) 10809 } 10810 10811 default: 10812 _, _ = key, value 10813 10814 } 10815 } 10816 *v = sv 10817 return nil 10818} 10819 10820func awsAwsjson11_deserializeDocumentSourceRevision(v **types.SourceRevision, value interface{}) error { 10821 if v == nil { 10822 return fmt.Errorf("unexpected nil of type %T", v) 10823 } 10824 if value == nil { 10825 return nil 10826 } 10827 10828 shape, ok := value.(map[string]interface{}) 10829 if !ok { 10830 return fmt.Errorf("unexpected JSON type %v", value) 10831 } 10832 10833 var sv *types.SourceRevision 10834 if *v == nil { 10835 sv = &types.SourceRevision{} 10836 } else { 10837 sv = *v 10838 } 10839 10840 for key, value := range shape { 10841 switch key { 10842 case "actionName": 10843 if value != nil { 10844 jtv, ok := value.(string) 10845 if !ok { 10846 return fmt.Errorf("expected ActionName to be of type string, got %T instead", value) 10847 } 10848 sv.ActionName = ptr.String(jtv) 10849 } 10850 10851 case "revisionId": 10852 if value != nil { 10853 jtv, ok := value.(string) 10854 if !ok { 10855 return fmt.Errorf("expected Revision to be of type string, got %T instead", value) 10856 } 10857 sv.RevisionId = ptr.String(jtv) 10858 } 10859 10860 case "revisionSummary": 10861 if value != nil { 10862 jtv, ok := value.(string) 10863 if !ok { 10864 return fmt.Errorf("expected RevisionSummary to be of type string, got %T instead", value) 10865 } 10866 sv.RevisionSummary = ptr.String(jtv) 10867 } 10868 10869 case "revisionUrl": 10870 if value != nil { 10871 jtv, ok := value.(string) 10872 if !ok { 10873 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 10874 } 10875 sv.RevisionUrl = ptr.String(jtv) 10876 } 10877 10878 default: 10879 _, _ = key, value 10880 10881 } 10882 } 10883 *v = sv 10884 return nil 10885} 10886 10887func awsAwsjson11_deserializeDocumentSourceRevisionList(v *[]types.SourceRevision, value interface{}) error { 10888 if v == nil { 10889 return fmt.Errorf("unexpected nil of type %T", v) 10890 } 10891 if value == nil { 10892 return nil 10893 } 10894 10895 shape, ok := value.([]interface{}) 10896 if !ok { 10897 return fmt.Errorf("unexpected JSON type %v", value) 10898 } 10899 10900 var cv []types.SourceRevision 10901 if *v == nil { 10902 cv = []types.SourceRevision{} 10903 } else { 10904 cv = *v 10905 } 10906 10907 for _, value := range shape { 10908 var col types.SourceRevision 10909 destAddr := &col 10910 if err := awsAwsjson11_deserializeDocumentSourceRevision(&destAddr, value); err != nil { 10911 return err 10912 } 10913 col = *destAddr 10914 cv = append(cv, col) 10915 10916 } 10917 *v = cv 10918 return nil 10919} 10920 10921func awsAwsjson11_deserializeDocumentStageActionDeclarationList(v *[]types.ActionDeclaration, value interface{}) error { 10922 if v == nil { 10923 return fmt.Errorf("unexpected nil of type %T", v) 10924 } 10925 if value == nil { 10926 return nil 10927 } 10928 10929 shape, ok := value.([]interface{}) 10930 if !ok { 10931 return fmt.Errorf("unexpected JSON type %v", value) 10932 } 10933 10934 var cv []types.ActionDeclaration 10935 if *v == nil { 10936 cv = []types.ActionDeclaration{} 10937 } else { 10938 cv = *v 10939 } 10940 10941 for _, value := range shape { 10942 var col types.ActionDeclaration 10943 destAddr := &col 10944 if err := awsAwsjson11_deserializeDocumentActionDeclaration(&destAddr, value); err != nil { 10945 return err 10946 } 10947 col = *destAddr 10948 cv = append(cv, col) 10949 10950 } 10951 *v = cv 10952 return nil 10953} 10954 10955func awsAwsjson11_deserializeDocumentStageBlockerDeclarationList(v *[]types.BlockerDeclaration, value interface{}) error { 10956 if v == nil { 10957 return fmt.Errorf("unexpected nil of type %T", v) 10958 } 10959 if value == nil { 10960 return nil 10961 } 10962 10963 shape, ok := value.([]interface{}) 10964 if !ok { 10965 return fmt.Errorf("unexpected JSON type %v", value) 10966 } 10967 10968 var cv []types.BlockerDeclaration 10969 if *v == nil { 10970 cv = []types.BlockerDeclaration{} 10971 } else { 10972 cv = *v 10973 } 10974 10975 for _, value := range shape { 10976 var col types.BlockerDeclaration 10977 destAddr := &col 10978 if err := awsAwsjson11_deserializeDocumentBlockerDeclaration(&destAddr, value); err != nil { 10979 return err 10980 } 10981 col = *destAddr 10982 cv = append(cv, col) 10983 10984 } 10985 *v = cv 10986 return nil 10987} 10988 10989func awsAwsjson11_deserializeDocumentStageContext(v **types.StageContext, value interface{}) error { 10990 if v == nil { 10991 return fmt.Errorf("unexpected nil of type %T", v) 10992 } 10993 if value == nil { 10994 return nil 10995 } 10996 10997 shape, ok := value.(map[string]interface{}) 10998 if !ok { 10999 return fmt.Errorf("unexpected JSON type %v", value) 11000 } 11001 11002 var sv *types.StageContext 11003 if *v == nil { 11004 sv = &types.StageContext{} 11005 } else { 11006 sv = *v 11007 } 11008 11009 for key, value := range shape { 11010 switch key { 11011 case "name": 11012 if value != nil { 11013 jtv, ok := value.(string) 11014 if !ok { 11015 return fmt.Errorf("expected StageName to be of type string, got %T instead", value) 11016 } 11017 sv.Name = ptr.String(jtv) 11018 } 11019 11020 default: 11021 _, _ = key, value 11022 11023 } 11024 } 11025 *v = sv 11026 return nil 11027} 11028 11029func awsAwsjson11_deserializeDocumentStageDeclaration(v **types.StageDeclaration, value interface{}) error { 11030 if v == nil { 11031 return fmt.Errorf("unexpected nil of type %T", v) 11032 } 11033 if value == nil { 11034 return nil 11035 } 11036 11037 shape, ok := value.(map[string]interface{}) 11038 if !ok { 11039 return fmt.Errorf("unexpected JSON type %v", value) 11040 } 11041 11042 var sv *types.StageDeclaration 11043 if *v == nil { 11044 sv = &types.StageDeclaration{} 11045 } else { 11046 sv = *v 11047 } 11048 11049 for key, value := range shape { 11050 switch key { 11051 case "actions": 11052 if err := awsAwsjson11_deserializeDocumentStageActionDeclarationList(&sv.Actions, value); err != nil { 11053 return err 11054 } 11055 11056 case "blockers": 11057 if err := awsAwsjson11_deserializeDocumentStageBlockerDeclarationList(&sv.Blockers, value); err != nil { 11058 return err 11059 } 11060 11061 case "name": 11062 if value != nil { 11063 jtv, ok := value.(string) 11064 if !ok { 11065 return fmt.Errorf("expected StageName to be of type string, got %T instead", value) 11066 } 11067 sv.Name = ptr.String(jtv) 11068 } 11069 11070 default: 11071 _, _ = key, value 11072 11073 } 11074 } 11075 *v = sv 11076 return nil 11077} 11078 11079func awsAwsjson11_deserializeDocumentStageExecution(v **types.StageExecution, value interface{}) error { 11080 if v == nil { 11081 return fmt.Errorf("unexpected nil of type %T", v) 11082 } 11083 if value == nil { 11084 return nil 11085 } 11086 11087 shape, ok := value.(map[string]interface{}) 11088 if !ok { 11089 return fmt.Errorf("unexpected JSON type %v", value) 11090 } 11091 11092 var sv *types.StageExecution 11093 if *v == nil { 11094 sv = &types.StageExecution{} 11095 } else { 11096 sv = *v 11097 } 11098 11099 for key, value := range shape { 11100 switch key { 11101 case "pipelineExecutionId": 11102 if value != nil { 11103 jtv, ok := value.(string) 11104 if !ok { 11105 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 11106 } 11107 sv.PipelineExecutionId = ptr.String(jtv) 11108 } 11109 11110 case "status": 11111 if value != nil { 11112 jtv, ok := value.(string) 11113 if !ok { 11114 return fmt.Errorf("expected StageExecutionStatus to be of type string, got %T instead", value) 11115 } 11116 sv.Status = types.StageExecutionStatus(jtv) 11117 } 11118 11119 default: 11120 _, _ = key, value 11121 11122 } 11123 } 11124 *v = sv 11125 return nil 11126} 11127 11128func awsAwsjson11_deserializeDocumentStageNotFoundException(v **types.StageNotFoundException, value interface{}) error { 11129 if v == nil { 11130 return fmt.Errorf("unexpected nil of type %T", v) 11131 } 11132 if value == nil { 11133 return nil 11134 } 11135 11136 shape, ok := value.(map[string]interface{}) 11137 if !ok { 11138 return fmt.Errorf("unexpected JSON type %v", value) 11139 } 11140 11141 var sv *types.StageNotFoundException 11142 if *v == nil { 11143 sv = &types.StageNotFoundException{} 11144 } else { 11145 sv = *v 11146 } 11147 11148 for key, value := range shape { 11149 switch key { 11150 case "message": 11151 if value != nil { 11152 jtv, ok := value.(string) 11153 if !ok { 11154 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 11155 } 11156 sv.Message = ptr.String(jtv) 11157 } 11158 11159 default: 11160 _, _ = key, value 11161 11162 } 11163 } 11164 *v = sv 11165 return nil 11166} 11167 11168func awsAwsjson11_deserializeDocumentStageNotRetryableException(v **types.StageNotRetryableException, value interface{}) error { 11169 if v == nil { 11170 return fmt.Errorf("unexpected nil of type %T", v) 11171 } 11172 if value == nil { 11173 return nil 11174 } 11175 11176 shape, ok := value.(map[string]interface{}) 11177 if !ok { 11178 return fmt.Errorf("unexpected JSON type %v", value) 11179 } 11180 11181 var sv *types.StageNotRetryableException 11182 if *v == nil { 11183 sv = &types.StageNotRetryableException{} 11184 } else { 11185 sv = *v 11186 } 11187 11188 for key, value := range shape { 11189 switch key { 11190 case "message": 11191 if value != nil { 11192 jtv, ok := value.(string) 11193 if !ok { 11194 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 11195 } 11196 sv.Message = ptr.String(jtv) 11197 } 11198 11199 default: 11200 _, _ = key, value 11201 11202 } 11203 } 11204 *v = sv 11205 return nil 11206} 11207 11208func awsAwsjson11_deserializeDocumentStageState(v **types.StageState, value interface{}) error { 11209 if v == nil { 11210 return fmt.Errorf("unexpected nil of type %T", v) 11211 } 11212 if value == nil { 11213 return nil 11214 } 11215 11216 shape, ok := value.(map[string]interface{}) 11217 if !ok { 11218 return fmt.Errorf("unexpected JSON type %v", value) 11219 } 11220 11221 var sv *types.StageState 11222 if *v == nil { 11223 sv = &types.StageState{} 11224 } else { 11225 sv = *v 11226 } 11227 11228 for key, value := range shape { 11229 switch key { 11230 case "actionStates": 11231 if err := awsAwsjson11_deserializeDocumentActionStateList(&sv.ActionStates, value); err != nil { 11232 return err 11233 } 11234 11235 case "inboundExecution": 11236 if err := awsAwsjson11_deserializeDocumentStageExecution(&sv.InboundExecution, value); err != nil { 11237 return err 11238 } 11239 11240 case "inboundTransitionState": 11241 if err := awsAwsjson11_deserializeDocumentTransitionState(&sv.InboundTransitionState, value); err != nil { 11242 return err 11243 } 11244 11245 case "latestExecution": 11246 if err := awsAwsjson11_deserializeDocumentStageExecution(&sv.LatestExecution, value); err != nil { 11247 return err 11248 } 11249 11250 case "stageName": 11251 if value != nil { 11252 jtv, ok := value.(string) 11253 if !ok { 11254 return fmt.Errorf("expected StageName to be of type string, got %T instead", value) 11255 } 11256 sv.StageName = ptr.String(jtv) 11257 } 11258 11259 default: 11260 _, _ = key, value 11261 11262 } 11263 } 11264 *v = sv 11265 return nil 11266} 11267 11268func awsAwsjson11_deserializeDocumentStageStateList(v *[]types.StageState, value interface{}) error { 11269 if v == nil { 11270 return fmt.Errorf("unexpected nil of type %T", v) 11271 } 11272 if value == nil { 11273 return nil 11274 } 11275 11276 shape, ok := value.([]interface{}) 11277 if !ok { 11278 return fmt.Errorf("unexpected JSON type %v", value) 11279 } 11280 11281 var cv []types.StageState 11282 if *v == nil { 11283 cv = []types.StageState{} 11284 } else { 11285 cv = *v 11286 } 11287 11288 for _, value := range shape { 11289 var col types.StageState 11290 destAddr := &col 11291 if err := awsAwsjson11_deserializeDocumentStageState(&destAddr, value); err != nil { 11292 return err 11293 } 11294 col = *destAddr 11295 cv = append(cv, col) 11296 11297 } 11298 *v = cv 11299 return nil 11300} 11301 11302func awsAwsjson11_deserializeDocumentStopExecutionTrigger(v **types.StopExecutionTrigger, value interface{}) error { 11303 if v == nil { 11304 return fmt.Errorf("unexpected nil of type %T", v) 11305 } 11306 if value == nil { 11307 return nil 11308 } 11309 11310 shape, ok := value.(map[string]interface{}) 11311 if !ok { 11312 return fmt.Errorf("unexpected JSON type %v", value) 11313 } 11314 11315 var sv *types.StopExecutionTrigger 11316 if *v == nil { 11317 sv = &types.StopExecutionTrigger{} 11318 } else { 11319 sv = *v 11320 } 11321 11322 for key, value := range shape { 11323 switch key { 11324 case "reason": 11325 if value != nil { 11326 jtv, ok := value.(string) 11327 if !ok { 11328 return fmt.Errorf("expected StopPipelineExecutionReason to be of type string, got %T instead", value) 11329 } 11330 sv.Reason = ptr.String(jtv) 11331 } 11332 11333 default: 11334 _, _ = key, value 11335 11336 } 11337 } 11338 *v = sv 11339 return nil 11340} 11341 11342func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 11343 if v == nil { 11344 return fmt.Errorf("unexpected nil of type %T", v) 11345 } 11346 if value == nil { 11347 return nil 11348 } 11349 11350 shape, ok := value.(map[string]interface{}) 11351 if !ok { 11352 return fmt.Errorf("unexpected JSON type %v", value) 11353 } 11354 11355 var sv *types.Tag 11356 if *v == nil { 11357 sv = &types.Tag{} 11358 } else { 11359 sv = *v 11360 } 11361 11362 for key, value := range shape { 11363 switch key { 11364 case "key": 11365 if value != nil { 11366 jtv, ok := value.(string) 11367 if !ok { 11368 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 11369 } 11370 sv.Key = ptr.String(jtv) 11371 } 11372 11373 case "value": 11374 if value != nil { 11375 jtv, ok := value.(string) 11376 if !ok { 11377 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 11378 } 11379 sv.Value = ptr.String(jtv) 11380 } 11381 11382 default: 11383 _, _ = key, value 11384 11385 } 11386 } 11387 *v = sv 11388 return nil 11389} 11390 11391func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error { 11392 if v == nil { 11393 return fmt.Errorf("unexpected nil of type %T", v) 11394 } 11395 if value == nil { 11396 return nil 11397 } 11398 11399 shape, ok := value.([]interface{}) 11400 if !ok { 11401 return fmt.Errorf("unexpected JSON type %v", value) 11402 } 11403 11404 var cv []types.Tag 11405 if *v == nil { 11406 cv = []types.Tag{} 11407 } else { 11408 cv = *v 11409 } 11410 11411 for _, value := range shape { 11412 var col types.Tag 11413 destAddr := &col 11414 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 11415 return err 11416 } 11417 col = *destAddr 11418 cv = append(cv, col) 11419 11420 } 11421 *v = cv 11422 return nil 11423} 11424 11425func awsAwsjson11_deserializeDocumentThirdPartyJob(v **types.ThirdPartyJob, value interface{}) error { 11426 if v == nil { 11427 return fmt.Errorf("unexpected nil of type %T", v) 11428 } 11429 if value == nil { 11430 return nil 11431 } 11432 11433 shape, ok := value.(map[string]interface{}) 11434 if !ok { 11435 return fmt.Errorf("unexpected JSON type %v", value) 11436 } 11437 11438 var sv *types.ThirdPartyJob 11439 if *v == nil { 11440 sv = &types.ThirdPartyJob{} 11441 } else { 11442 sv = *v 11443 } 11444 11445 for key, value := range shape { 11446 switch key { 11447 case "clientId": 11448 if value != nil { 11449 jtv, ok := value.(string) 11450 if !ok { 11451 return fmt.Errorf("expected ClientId to be of type string, got %T instead", value) 11452 } 11453 sv.ClientId = ptr.String(jtv) 11454 } 11455 11456 case "jobId": 11457 if value != nil { 11458 jtv, ok := value.(string) 11459 if !ok { 11460 return fmt.Errorf("expected JobId to be of type string, got %T instead", value) 11461 } 11462 sv.JobId = ptr.String(jtv) 11463 } 11464 11465 default: 11466 _, _ = key, value 11467 11468 } 11469 } 11470 *v = sv 11471 return nil 11472} 11473 11474func awsAwsjson11_deserializeDocumentThirdPartyJobData(v **types.ThirdPartyJobData, value interface{}) error { 11475 if v == nil { 11476 return fmt.Errorf("unexpected nil of type %T", v) 11477 } 11478 if value == nil { 11479 return nil 11480 } 11481 11482 shape, ok := value.(map[string]interface{}) 11483 if !ok { 11484 return fmt.Errorf("unexpected JSON type %v", value) 11485 } 11486 11487 var sv *types.ThirdPartyJobData 11488 if *v == nil { 11489 sv = &types.ThirdPartyJobData{} 11490 } else { 11491 sv = *v 11492 } 11493 11494 for key, value := range shape { 11495 switch key { 11496 case "actionConfiguration": 11497 if err := awsAwsjson11_deserializeDocumentActionConfiguration(&sv.ActionConfiguration, value); err != nil { 11498 return err 11499 } 11500 11501 case "actionTypeId": 11502 if err := awsAwsjson11_deserializeDocumentActionTypeId(&sv.ActionTypeId, value); err != nil { 11503 return err 11504 } 11505 11506 case "artifactCredentials": 11507 if err := awsAwsjson11_deserializeDocumentAWSSessionCredentials(&sv.ArtifactCredentials, value); err != nil { 11508 return err 11509 } 11510 11511 case "continuationToken": 11512 if value != nil { 11513 jtv, ok := value.(string) 11514 if !ok { 11515 return fmt.Errorf("expected ContinuationToken to be of type string, got %T instead", value) 11516 } 11517 sv.ContinuationToken = ptr.String(jtv) 11518 } 11519 11520 case "encryptionKey": 11521 if err := awsAwsjson11_deserializeDocumentEncryptionKey(&sv.EncryptionKey, value); err != nil { 11522 return err 11523 } 11524 11525 case "inputArtifacts": 11526 if err := awsAwsjson11_deserializeDocumentArtifactList(&sv.InputArtifacts, value); err != nil { 11527 return err 11528 } 11529 11530 case "outputArtifacts": 11531 if err := awsAwsjson11_deserializeDocumentArtifactList(&sv.OutputArtifacts, value); err != nil { 11532 return err 11533 } 11534 11535 case "pipelineContext": 11536 if err := awsAwsjson11_deserializeDocumentPipelineContext(&sv.PipelineContext, value); err != nil { 11537 return err 11538 } 11539 11540 default: 11541 _, _ = key, value 11542 11543 } 11544 } 11545 *v = sv 11546 return nil 11547} 11548 11549func awsAwsjson11_deserializeDocumentThirdPartyJobDetails(v **types.ThirdPartyJobDetails, value interface{}) error { 11550 if v == nil { 11551 return fmt.Errorf("unexpected nil of type %T", v) 11552 } 11553 if value == nil { 11554 return nil 11555 } 11556 11557 shape, ok := value.(map[string]interface{}) 11558 if !ok { 11559 return fmt.Errorf("unexpected JSON type %v", value) 11560 } 11561 11562 var sv *types.ThirdPartyJobDetails 11563 if *v == nil { 11564 sv = &types.ThirdPartyJobDetails{} 11565 } else { 11566 sv = *v 11567 } 11568 11569 for key, value := range shape { 11570 switch key { 11571 case "data": 11572 if err := awsAwsjson11_deserializeDocumentThirdPartyJobData(&sv.Data, value); err != nil { 11573 return err 11574 } 11575 11576 case "id": 11577 if value != nil { 11578 jtv, ok := value.(string) 11579 if !ok { 11580 return fmt.Errorf("expected ThirdPartyJobId to be of type string, got %T instead", value) 11581 } 11582 sv.Id = ptr.String(jtv) 11583 } 11584 11585 case "nonce": 11586 if value != nil { 11587 jtv, ok := value.(string) 11588 if !ok { 11589 return fmt.Errorf("expected Nonce to be of type string, got %T instead", value) 11590 } 11591 sv.Nonce = ptr.String(jtv) 11592 } 11593 11594 default: 11595 _, _ = key, value 11596 11597 } 11598 } 11599 *v = sv 11600 return nil 11601} 11602 11603func awsAwsjson11_deserializeDocumentThirdPartyJobList(v *[]types.ThirdPartyJob, value interface{}) error { 11604 if v == nil { 11605 return fmt.Errorf("unexpected nil of type %T", v) 11606 } 11607 if value == nil { 11608 return nil 11609 } 11610 11611 shape, ok := value.([]interface{}) 11612 if !ok { 11613 return fmt.Errorf("unexpected JSON type %v", value) 11614 } 11615 11616 var cv []types.ThirdPartyJob 11617 if *v == nil { 11618 cv = []types.ThirdPartyJob{} 11619 } else { 11620 cv = *v 11621 } 11622 11623 for _, value := range shape { 11624 var col types.ThirdPartyJob 11625 destAddr := &col 11626 if err := awsAwsjson11_deserializeDocumentThirdPartyJob(&destAddr, value); err != nil { 11627 return err 11628 } 11629 col = *destAddr 11630 cv = append(cv, col) 11631 11632 } 11633 *v = cv 11634 return nil 11635} 11636 11637func awsAwsjson11_deserializeDocumentTooManyTagsException(v **types.TooManyTagsException, value interface{}) error { 11638 if v == nil { 11639 return fmt.Errorf("unexpected nil of type %T", v) 11640 } 11641 if value == nil { 11642 return nil 11643 } 11644 11645 shape, ok := value.(map[string]interface{}) 11646 if !ok { 11647 return fmt.Errorf("unexpected JSON type %v", value) 11648 } 11649 11650 var sv *types.TooManyTagsException 11651 if *v == nil { 11652 sv = &types.TooManyTagsException{} 11653 } else { 11654 sv = *v 11655 } 11656 11657 for key, value := range shape { 11658 switch key { 11659 case "message": 11660 if value != nil { 11661 jtv, ok := value.(string) 11662 if !ok { 11663 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 11664 } 11665 sv.Message = ptr.String(jtv) 11666 } 11667 11668 default: 11669 _, _ = key, value 11670 11671 } 11672 } 11673 *v = sv 11674 return nil 11675} 11676 11677func awsAwsjson11_deserializeDocumentTransitionState(v **types.TransitionState, value interface{}) error { 11678 if v == nil { 11679 return fmt.Errorf("unexpected nil of type %T", v) 11680 } 11681 if value == nil { 11682 return nil 11683 } 11684 11685 shape, ok := value.(map[string]interface{}) 11686 if !ok { 11687 return fmt.Errorf("unexpected JSON type %v", value) 11688 } 11689 11690 var sv *types.TransitionState 11691 if *v == nil { 11692 sv = &types.TransitionState{} 11693 } else { 11694 sv = *v 11695 } 11696 11697 for key, value := range shape { 11698 switch key { 11699 case "disabledReason": 11700 if value != nil { 11701 jtv, ok := value.(string) 11702 if !ok { 11703 return fmt.Errorf("expected DisabledReason to be of type string, got %T instead", value) 11704 } 11705 sv.DisabledReason = ptr.String(jtv) 11706 } 11707 11708 case "enabled": 11709 if value != nil { 11710 jtv, ok := value.(bool) 11711 if !ok { 11712 return fmt.Errorf("expected Enabled to be of type *bool, got %T instead", value) 11713 } 11714 sv.Enabled = jtv 11715 } 11716 11717 case "lastChangedAt": 11718 if value != nil { 11719 jtv, ok := value.(json.Number) 11720 if !ok { 11721 return fmt.Errorf("expected LastChangedAt to be json.Number, got %T instead", value) 11722 } 11723 f64, err := jtv.Float64() 11724 if err != nil { 11725 return err 11726 } 11727 sv.LastChangedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 11728 } 11729 11730 case "lastChangedBy": 11731 if value != nil { 11732 jtv, ok := value.(string) 11733 if !ok { 11734 return fmt.Errorf("expected LastChangedBy to be of type string, got %T instead", value) 11735 } 11736 sv.LastChangedBy = ptr.String(jtv) 11737 } 11738 11739 default: 11740 _, _ = key, value 11741 11742 } 11743 } 11744 *v = sv 11745 return nil 11746} 11747 11748func awsAwsjson11_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error { 11749 if v == nil { 11750 return fmt.Errorf("unexpected nil of type %T", v) 11751 } 11752 if value == nil { 11753 return nil 11754 } 11755 11756 shape, ok := value.(map[string]interface{}) 11757 if !ok { 11758 return fmt.Errorf("unexpected JSON type %v", value) 11759 } 11760 11761 var sv *types.ValidationException 11762 if *v == nil { 11763 sv = &types.ValidationException{} 11764 } else { 11765 sv = *v 11766 } 11767 11768 for key, value := range shape { 11769 switch key { 11770 case "message": 11771 if value != nil { 11772 jtv, ok := value.(string) 11773 if !ok { 11774 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 11775 } 11776 sv.Message = ptr.String(jtv) 11777 } 11778 11779 default: 11780 _, _ = key, value 11781 11782 } 11783 } 11784 *v = sv 11785 return nil 11786} 11787 11788func awsAwsjson11_deserializeDocumentWebhookAuthConfiguration(v **types.WebhookAuthConfiguration, value interface{}) error { 11789 if v == nil { 11790 return fmt.Errorf("unexpected nil of type %T", v) 11791 } 11792 if value == nil { 11793 return nil 11794 } 11795 11796 shape, ok := value.(map[string]interface{}) 11797 if !ok { 11798 return fmt.Errorf("unexpected JSON type %v", value) 11799 } 11800 11801 var sv *types.WebhookAuthConfiguration 11802 if *v == nil { 11803 sv = &types.WebhookAuthConfiguration{} 11804 } else { 11805 sv = *v 11806 } 11807 11808 for key, value := range shape { 11809 switch key { 11810 case "AllowedIPRange": 11811 if value != nil { 11812 jtv, ok := value.(string) 11813 if !ok { 11814 return fmt.Errorf("expected WebhookAuthConfigurationAllowedIPRange to be of type string, got %T instead", value) 11815 } 11816 sv.AllowedIPRange = ptr.String(jtv) 11817 } 11818 11819 case "SecretToken": 11820 if value != nil { 11821 jtv, ok := value.(string) 11822 if !ok { 11823 return fmt.Errorf("expected WebhookAuthConfigurationSecretToken to be of type string, got %T instead", value) 11824 } 11825 sv.SecretToken = ptr.String(jtv) 11826 } 11827 11828 default: 11829 _, _ = key, value 11830 11831 } 11832 } 11833 *v = sv 11834 return nil 11835} 11836 11837func awsAwsjson11_deserializeDocumentWebhookDefinition(v **types.WebhookDefinition, value interface{}) error { 11838 if v == nil { 11839 return fmt.Errorf("unexpected nil of type %T", v) 11840 } 11841 if value == nil { 11842 return nil 11843 } 11844 11845 shape, ok := value.(map[string]interface{}) 11846 if !ok { 11847 return fmt.Errorf("unexpected JSON type %v", value) 11848 } 11849 11850 var sv *types.WebhookDefinition 11851 if *v == nil { 11852 sv = &types.WebhookDefinition{} 11853 } else { 11854 sv = *v 11855 } 11856 11857 for key, value := range shape { 11858 switch key { 11859 case "authentication": 11860 if value != nil { 11861 jtv, ok := value.(string) 11862 if !ok { 11863 return fmt.Errorf("expected WebhookAuthenticationType to be of type string, got %T instead", value) 11864 } 11865 sv.Authentication = types.WebhookAuthenticationType(jtv) 11866 } 11867 11868 case "authenticationConfiguration": 11869 if err := awsAwsjson11_deserializeDocumentWebhookAuthConfiguration(&sv.AuthenticationConfiguration, value); err != nil { 11870 return err 11871 } 11872 11873 case "filters": 11874 if err := awsAwsjson11_deserializeDocumentWebhookFilters(&sv.Filters, value); err != nil { 11875 return err 11876 } 11877 11878 case "name": 11879 if value != nil { 11880 jtv, ok := value.(string) 11881 if !ok { 11882 return fmt.Errorf("expected WebhookName to be of type string, got %T instead", value) 11883 } 11884 sv.Name = ptr.String(jtv) 11885 } 11886 11887 case "targetAction": 11888 if value != nil { 11889 jtv, ok := value.(string) 11890 if !ok { 11891 return fmt.Errorf("expected ActionName to be of type string, got %T instead", value) 11892 } 11893 sv.TargetAction = ptr.String(jtv) 11894 } 11895 11896 case "targetPipeline": 11897 if value != nil { 11898 jtv, ok := value.(string) 11899 if !ok { 11900 return fmt.Errorf("expected PipelineName to be of type string, got %T instead", value) 11901 } 11902 sv.TargetPipeline = ptr.String(jtv) 11903 } 11904 11905 default: 11906 _, _ = key, value 11907 11908 } 11909 } 11910 *v = sv 11911 return nil 11912} 11913 11914func awsAwsjson11_deserializeDocumentWebhookFilterRule(v **types.WebhookFilterRule, value interface{}) error { 11915 if v == nil { 11916 return fmt.Errorf("unexpected nil of type %T", v) 11917 } 11918 if value == nil { 11919 return nil 11920 } 11921 11922 shape, ok := value.(map[string]interface{}) 11923 if !ok { 11924 return fmt.Errorf("unexpected JSON type %v", value) 11925 } 11926 11927 var sv *types.WebhookFilterRule 11928 if *v == nil { 11929 sv = &types.WebhookFilterRule{} 11930 } else { 11931 sv = *v 11932 } 11933 11934 for key, value := range shape { 11935 switch key { 11936 case "jsonPath": 11937 if value != nil { 11938 jtv, ok := value.(string) 11939 if !ok { 11940 return fmt.Errorf("expected JsonPath to be of type string, got %T instead", value) 11941 } 11942 sv.JsonPath = ptr.String(jtv) 11943 } 11944 11945 case "matchEquals": 11946 if value != nil { 11947 jtv, ok := value.(string) 11948 if !ok { 11949 return fmt.Errorf("expected MatchEquals to be of type string, got %T instead", value) 11950 } 11951 sv.MatchEquals = ptr.String(jtv) 11952 } 11953 11954 default: 11955 _, _ = key, value 11956 11957 } 11958 } 11959 *v = sv 11960 return nil 11961} 11962 11963func awsAwsjson11_deserializeDocumentWebhookFilters(v *[]types.WebhookFilterRule, value interface{}) error { 11964 if v == nil { 11965 return fmt.Errorf("unexpected nil of type %T", v) 11966 } 11967 if value == nil { 11968 return nil 11969 } 11970 11971 shape, ok := value.([]interface{}) 11972 if !ok { 11973 return fmt.Errorf("unexpected JSON type %v", value) 11974 } 11975 11976 var cv []types.WebhookFilterRule 11977 if *v == nil { 11978 cv = []types.WebhookFilterRule{} 11979 } else { 11980 cv = *v 11981 } 11982 11983 for _, value := range shape { 11984 var col types.WebhookFilterRule 11985 destAddr := &col 11986 if err := awsAwsjson11_deserializeDocumentWebhookFilterRule(&destAddr, value); err != nil { 11987 return err 11988 } 11989 col = *destAddr 11990 cv = append(cv, col) 11991 11992 } 11993 *v = cv 11994 return nil 11995} 11996 11997func awsAwsjson11_deserializeDocumentWebhookList(v *[]types.ListWebhookItem, value interface{}) error { 11998 if v == nil { 11999 return fmt.Errorf("unexpected nil of type %T", v) 12000 } 12001 if value == nil { 12002 return nil 12003 } 12004 12005 shape, ok := value.([]interface{}) 12006 if !ok { 12007 return fmt.Errorf("unexpected JSON type %v", value) 12008 } 12009 12010 var cv []types.ListWebhookItem 12011 if *v == nil { 12012 cv = []types.ListWebhookItem{} 12013 } else { 12014 cv = *v 12015 } 12016 12017 for _, value := range shape { 12018 var col types.ListWebhookItem 12019 destAddr := &col 12020 if err := awsAwsjson11_deserializeDocumentListWebhookItem(&destAddr, value); err != nil { 12021 return err 12022 } 12023 col = *destAddr 12024 cv = append(cv, col) 12025 12026 } 12027 *v = cv 12028 return nil 12029} 12030 12031func awsAwsjson11_deserializeDocumentWebhookNotFoundException(v **types.WebhookNotFoundException, value interface{}) error { 12032 if v == nil { 12033 return fmt.Errorf("unexpected nil of type %T", v) 12034 } 12035 if value == nil { 12036 return nil 12037 } 12038 12039 shape, ok := value.(map[string]interface{}) 12040 if !ok { 12041 return fmt.Errorf("unexpected JSON type %v", value) 12042 } 12043 12044 var sv *types.WebhookNotFoundException 12045 if *v == nil { 12046 sv = &types.WebhookNotFoundException{} 12047 } else { 12048 sv = *v 12049 } 12050 12051 for key, value := range shape { 12052 switch key { 12053 default: 12054 _, _ = key, value 12055 12056 } 12057 } 12058 *v = sv 12059 return nil 12060} 12061 12062func awsAwsjson11_deserializeOpDocumentAcknowledgeJobOutput(v **AcknowledgeJobOutput, value interface{}) error { 12063 if v == nil { 12064 return fmt.Errorf("unexpected nil of type %T", v) 12065 } 12066 if value == nil { 12067 return nil 12068 } 12069 12070 shape, ok := value.(map[string]interface{}) 12071 if !ok { 12072 return fmt.Errorf("unexpected JSON type %v", value) 12073 } 12074 12075 var sv *AcknowledgeJobOutput 12076 if *v == nil { 12077 sv = &AcknowledgeJobOutput{} 12078 } else { 12079 sv = *v 12080 } 12081 12082 for key, value := range shape { 12083 switch key { 12084 case "status": 12085 if value != nil { 12086 jtv, ok := value.(string) 12087 if !ok { 12088 return fmt.Errorf("expected JobStatus to be of type string, got %T instead", value) 12089 } 12090 sv.Status = types.JobStatus(jtv) 12091 } 12092 12093 default: 12094 _, _ = key, value 12095 12096 } 12097 } 12098 *v = sv 12099 return nil 12100} 12101 12102func awsAwsjson11_deserializeOpDocumentAcknowledgeThirdPartyJobOutput(v **AcknowledgeThirdPartyJobOutput, value interface{}) error { 12103 if v == nil { 12104 return fmt.Errorf("unexpected nil of type %T", v) 12105 } 12106 if value == nil { 12107 return nil 12108 } 12109 12110 shape, ok := value.(map[string]interface{}) 12111 if !ok { 12112 return fmt.Errorf("unexpected JSON type %v", value) 12113 } 12114 12115 var sv *AcknowledgeThirdPartyJobOutput 12116 if *v == nil { 12117 sv = &AcknowledgeThirdPartyJobOutput{} 12118 } else { 12119 sv = *v 12120 } 12121 12122 for key, value := range shape { 12123 switch key { 12124 case "status": 12125 if value != nil { 12126 jtv, ok := value.(string) 12127 if !ok { 12128 return fmt.Errorf("expected JobStatus to be of type string, got %T instead", value) 12129 } 12130 sv.Status = types.JobStatus(jtv) 12131 } 12132 12133 default: 12134 _, _ = key, value 12135 12136 } 12137 } 12138 *v = sv 12139 return nil 12140} 12141 12142func awsAwsjson11_deserializeOpDocumentCreateCustomActionTypeOutput(v **CreateCustomActionTypeOutput, value interface{}) error { 12143 if v == nil { 12144 return fmt.Errorf("unexpected nil of type %T", v) 12145 } 12146 if value == nil { 12147 return nil 12148 } 12149 12150 shape, ok := value.(map[string]interface{}) 12151 if !ok { 12152 return fmt.Errorf("unexpected JSON type %v", value) 12153 } 12154 12155 var sv *CreateCustomActionTypeOutput 12156 if *v == nil { 12157 sv = &CreateCustomActionTypeOutput{} 12158 } else { 12159 sv = *v 12160 } 12161 12162 for key, value := range shape { 12163 switch key { 12164 case "actionType": 12165 if err := awsAwsjson11_deserializeDocumentActionType(&sv.ActionType, value); err != nil { 12166 return err 12167 } 12168 12169 case "tags": 12170 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil { 12171 return err 12172 } 12173 12174 default: 12175 _, _ = key, value 12176 12177 } 12178 } 12179 *v = sv 12180 return nil 12181} 12182 12183func awsAwsjson11_deserializeOpDocumentCreatePipelineOutput(v **CreatePipelineOutput, value interface{}) error { 12184 if v == nil { 12185 return fmt.Errorf("unexpected nil of type %T", v) 12186 } 12187 if value == nil { 12188 return nil 12189 } 12190 12191 shape, ok := value.(map[string]interface{}) 12192 if !ok { 12193 return fmt.Errorf("unexpected JSON type %v", value) 12194 } 12195 12196 var sv *CreatePipelineOutput 12197 if *v == nil { 12198 sv = &CreatePipelineOutput{} 12199 } else { 12200 sv = *v 12201 } 12202 12203 for key, value := range shape { 12204 switch key { 12205 case "pipeline": 12206 if err := awsAwsjson11_deserializeDocumentPipelineDeclaration(&sv.Pipeline, value); err != nil { 12207 return err 12208 } 12209 12210 case "tags": 12211 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil { 12212 return err 12213 } 12214 12215 default: 12216 _, _ = key, value 12217 12218 } 12219 } 12220 *v = sv 12221 return nil 12222} 12223 12224func awsAwsjson11_deserializeOpDocumentDeleteWebhookOutput(v **DeleteWebhookOutput, value interface{}) error { 12225 if v == nil { 12226 return fmt.Errorf("unexpected nil of type %T", v) 12227 } 12228 if value == nil { 12229 return nil 12230 } 12231 12232 shape, ok := value.(map[string]interface{}) 12233 if !ok { 12234 return fmt.Errorf("unexpected JSON type %v", value) 12235 } 12236 12237 var sv *DeleteWebhookOutput 12238 if *v == nil { 12239 sv = &DeleteWebhookOutput{} 12240 } else { 12241 sv = *v 12242 } 12243 12244 for key, value := range shape { 12245 switch key { 12246 default: 12247 _, _ = key, value 12248 12249 } 12250 } 12251 *v = sv 12252 return nil 12253} 12254 12255func awsAwsjson11_deserializeOpDocumentDeregisterWebhookWithThirdPartyOutput(v **DeregisterWebhookWithThirdPartyOutput, value interface{}) error { 12256 if v == nil { 12257 return fmt.Errorf("unexpected nil of type %T", v) 12258 } 12259 if value == nil { 12260 return nil 12261 } 12262 12263 shape, ok := value.(map[string]interface{}) 12264 if !ok { 12265 return fmt.Errorf("unexpected JSON type %v", value) 12266 } 12267 12268 var sv *DeregisterWebhookWithThirdPartyOutput 12269 if *v == nil { 12270 sv = &DeregisterWebhookWithThirdPartyOutput{} 12271 } else { 12272 sv = *v 12273 } 12274 12275 for key, value := range shape { 12276 switch key { 12277 default: 12278 _, _ = key, value 12279 12280 } 12281 } 12282 *v = sv 12283 return nil 12284} 12285 12286func awsAwsjson11_deserializeOpDocumentGetActionTypeOutput(v **GetActionTypeOutput, value interface{}) error { 12287 if v == nil { 12288 return fmt.Errorf("unexpected nil of type %T", v) 12289 } 12290 if value == nil { 12291 return nil 12292 } 12293 12294 shape, ok := value.(map[string]interface{}) 12295 if !ok { 12296 return fmt.Errorf("unexpected JSON type %v", value) 12297 } 12298 12299 var sv *GetActionTypeOutput 12300 if *v == nil { 12301 sv = &GetActionTypeOutput{} 12302 } else { 12303 sv = *v 12304 } 12305 12306 for key, value := range shape { 12307 switch key { 12308 case "actionType": 12309 if err := awsAwsjson11_deserializeDocumentActionTypeDeclaration(&sv.ActionType, value); err != nil { 12310 return err 12311 } 12312 12313 default: 12314 _, _ = key, value 12315 12316 } 12317 } 12318 *v = sv 12319 return nil 12320} 12321 12322func awsAwsjson11_deserializeOpDocumentGetJobDetailsOutput(v **GetJobDetailsOutput, value interface{}) error { 12323 if v == nil { 12324 return fmt.Errorf("unexpected nil of type %T", v) 12325 } 12326 if value == nil { 12327 return nil 12328 } 12329 12330 shape, ok := value.(map[string]interface{}) 12331 if !ok { 12332 return fmt.Errorf("unexpected JSON type %v", value) 12333 } 12334 12335 var sv *GetJobDetailsOutput 12336 if *v == nil { 12337 sv = &GetJobDetailsOutput{} 12338 } else { 12339 sv = *v 12340 } 12341 12342 for key, value := range shape { 12343 switch key { 12344 case "jobDetails": 12345 if err := awsAwsjson11_deserializeDocumentJobDetails(&sv.JobDetails, value); err != nil { 12346 return err 12347 } 12348 12349 default: 12350 _, _ = key, value 12351 12352 } 12353 } 12354 *v = sv 12355 return nil 12356} 12357 12358func awsAwsjson11_deserializeOpDocumentGetPipelineExecutionOutput(v **GetPipelineExecutionOutput, value interface{}) error { 12359 if v == nil { 12360 return fmt.Errorf("unexpected nil of type %T", v) 12361 } 12362 if value == nil { 12363 return nil 12364 } 12365 12366 shape, ok := value.(map[string]interface{}) 12367 if !ok { 12368 return fmt.Errorf("unexpected JSON type %v", value) 12369 } 12370 12371 var sv *GetPipelineExecutionOutput 12372 if *v == nil { 12373 sv = &GetPipelineExecutionOutput{} 12374 } else { 12375 sv = *v 12376 } 12377 12378 for key, value := range shape { 12379 switch key { 12380 case "pipelineExecution": 12381 if err := awsAwsjson11_deserializeDocumentPipelineExecution(&sv.PipelineExecution, value); err != nil { 12382 return err 12383 } 12384 12385 default: 12386 _, _ = key, value 12387 12388 } 12389 } 12390 *v = sv 12391 return nil 12392} 12393 12394func awsAwsjson11_deserializeOpDocumentGetPipelineOutput(v **GetPipelineOutput, value interface{}) error { 12395 if v == nil { 12396 return fmt.Errorf("unexpected nil of type %T", v) 12397 } 12398 if value == nil { 12399 return nil 12400 } 12401 12402 shape, ok := value.(map[string]interface{}) 12403 if !ok { 12404 return fmt.Errorf("unexpected JSON type %v", value) 12405 } 12406 12407 var sv *GetPipelineOutput 12408 if *v == nil { 12409 sv = &GetPipelineOutput{} 12410 } else { 12411 sv = *v 12412 } 12413 12414 for key, value := range shape { 12415 switch key { 12416 case "metadata": 12417 if err := awsAwsjson11_deserializeDocumentPipelineMetadata(&sv.Metadata, value); err != nil { 12418 return err 12419 } 12420 12421 case "pipeline": 12422 if err := awsAwsjson11_deserializeDocumentPipelineDeclaration(&sv.Pipeline, value); err != nil { 12423 return err 12424 } 12425 12426 default: 12427 _, _ = key, value 12428 12429 } 12430 } 12431 *v = sv 12432 return nil 12433} 12434 12435func awsAwsjson11_deserializeOpDocumentGetPipelineStateOutput(v **GetPipelineStateOutput, value interface{}) error { 12436 if v == nil { 12437 return fmt.Errorf("unexpected nil of type %T", v) 12438 } 12439 if value == nil { 12440 return nil 12441 } 12442 12443 shape, ok := value.(map[string]interface{}) 12444 if !ok { 12445 return fmt.Errorf("unexpected JSON type %v", value) 12446 } 12447 12448 var sv *GetPipelineStateOutput 12449 if *v == nil { 12450 sv = &GetPipelineStateOutput{} 12451 } else { 12452 sv = *v 12453 } 12454 12455 for key, value := range shape { 12456 switch key { 12457 case "created": 12458 if value != nil { 12459 jtv, ok := value.(json.Number) 12460 if !ok { 12461 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 12462 } 12463 f64, err := jtv.Float64() 12464 if err != nil { 12465 return err 12466 } 12467 sv.Created = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12468 } 12469 12470 case "pipelineName": 12471 if value != nil { 12472 jtv, ok := value.(string) 12473 if !ok { 12474 return fmt.Errorf("expected PipelineName to be of type string, got %T instead", value) 12475 } 12476 sv.PipelineName = ptr.String(jtv) 12477 } 12478 12479 case "pipelineVersion": 12480 if value != nil { 12481 jtv, ok := value.(json.Number) 12482 if !ok { 12483 return fmt.Errorf("expected PipelineVersion to be json.Number, got %T instead", value) 12484 } 12485 i64, err := jtv.Int64() 12486 if err != nil { 12487 return err 12488 } 12489 sv.PipelineVersion = ptr.Int32(int32(i64)) 12490 } 12491 12492 case "stageStates": 12493 if err := awsAwsjson11_deserializeDocumentStageStateList(&sv.StageStates, value); err != nil { 12494 return err 12495 } 12496 12497 case "updated": 12498 if value != nil { 12499 jtv, ok := value.(json.Number) 12500 if !ok { 12501 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 12502 } 12503 f64, err := jtv.Float64() 12504 if err != nil { 12505 return err 12506 } 12507 sv.Updated = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12508 } 12509 12510 default: 12511 _, _ = key, value 12512 12513 } 12514 } 12515 *v = sv 12516 return nil 12517} 12518 12519func awsAwsjson11_deserializeOpDocumentGetThirdPartyJobDetailsOutput(v **GetThirdPartyJobDetailsOutput, value interface{}) error { 12520 if v == nil { 12521 return fmt.Errorf("unexpected nil of type %T", v) 12522 } 12523 if value == nil { 12524 return nil 12525 } 12526 12527 shape, ok := value.(map[string]interface{}) 12528 if !ok { 12529 return fmt.Errorf("unexpected JSON type %v", value) 12530 } 12531 12532 var sv *GetThirdPartyJobDetailsOutput 12533 if *v == nil { 12534 sv = &GetThirdPartyJobDetailsOutput{} 12535 } else { 12536 sv = *v 12537 } 12538 12539 for key, value := range shape { 12540 switch key { 12541 case "jobDetails": 12542 if err := awsAwsjson11_deserializeDocumentThirdPartyJobDetails(&sv.JobDetails, value); err != nil { 12543 return err 12544 } 12545 12546 default: 12547 _, _ = key, value 12548 12549 } 12550 } 12551 *v = sv 12552 return nil 12553} 12554 12555func awsAwsjson11_deserializeOpDocumentListActionExecutionsOutput(v **ListActionExecutionsOutput, value interface{}) error { 12556 if v == nil { 12557 return fmt.Errorf("unexpected nil of type %T", v) 12558 } 12559 if value == nil { 12560 return nil 12561 } 12562 12563 shape, ok := value.(map[string]interface{}) 12564 if !ok { 12565 return fmt.Errorf("unexpected JSON type %v", value) 12566 } 12567 12568 var sv *ListActionExecutionsOutput 12569 if *v == nil { 12570 sv = &ListActionExecutionsOutput{} 12571 } else { 12572 sv = *v 12573 } 12574 12575 for key, value := range shape { 12576 switch key { 12577 case "actionExecutionDetails": 12578 if err := awsAwsjson11_deserializeDocumentActionExecutionDetailList(&sv.ActionExecutionDetails, value); err != nil { 12579 return err 12580 } 12581 12582 case "nextToken": 12583 if value != nil { 12584 jtv, ok := value.(string) 12585 if !ok { 12586 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12587 } 12588 sv.NextToken = ptr.String(jtv) 12589 } 12590 12591 default: 12592 _, _ = key, value 12593 12594 } 12595 } 12596 *v = sv 12597 return nil 12598} 12599 12600func awsAwsjson11_deserializeOpDocumentListActionTypesOutput(v **ListActionTypesOutput, 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 *ListActionTypesOutput 12614 if *v == nil { 12615 sv = &ListActionTypesOutput{} 12616 } else { 12617 sv = *v 12618 } 12619 12620 for key, value := range shape { 12621 switch key { 12622 case "actionTypes": 12623 if err := awsAwsjson11_deserializeDocumentActionTypeList(&sv.ActionTypes, 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_deserializeOpDocumentListPipelineExecutionsOutput(v **ListPipelineExecutionsOutput, 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 *ListPipelineExecutionsOutput 12659 if *v == nil { 12660 sv = &ListPipelineExecutionsOutput{} 12661 } else { 12662 sv = *v 12663 } 12664 12665 for key, value := range shape { 12666 switch key { 12667 case "nextToken": 12668 if value != nil { 12669 jtv, ok := value.(string) 12670 if !ok { 12671 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12672 } 12673 sv.NextToken = ptr.String(jtv) 12674 } 12675 12676 case "pipelineExecutionSummaries": 12677 if err := awsAwsjson11_deserializeDocumentPipelineExecutionSummaryList(&sv.PipelineExecutionSummaries, value); err != nil { 12678 return err 12679 } 12680 12681 default: 12682 _, _ = key, value 12683 12684 } 12685 } 12686 *v = sv 12687 return nil 12688} 12689 12690func awsAwsjson11_deserializeOpDocumentListPipelinesOutput(v **ListPipelinesOutput, 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 *ListPipelinesOutput 12704 if *v == nil { 12705 sv = &ListPipelinesOutput{} 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 "pipelines": 12722 if err := awsAwsjson11_deserializeDocumentPipelineList(&sv.Pipelines, 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_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, 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 *ListTagsForResourceOutput 12749 if *v == nil { 12750 sv = &ListTagsForResourceOutput{} 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 "tags": 12767 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, 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_deserializeOpDocumentListWebhooksOutput(v **ListWebhooksOutput, 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 *ListWebhooksOutput 12794 if *v == nil { 12795 sv = &ListWebhooksOutput{} 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 "webhooks": 12812 if err := awsAwsjson11_deserializeDocumentWebhookList(&sv.Webhooks, 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_deserializeOpDocumentPollForJobsOutput(v **PollForJobsOutput, 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 *PollForJobsOutput 12839 if *v == nil { 12840 sv = &PollForJobsOutput{} 12841 } else { 12842 sv = *v 12843 } 12844 12845 for key, value := range shape { 12846 switch key { 12847 case "jobs": 12848 if err := awsAwsjson11_deserializeDocumentJobList(&sv.Jobs, value); err != nil { 12849 return err 12850 } 12851 12852 default: 12853 _, _ = key, value 12854 12855 } 12856 } 12857 *v = sv 12858 return nil 12859} 12860 12861func awsAwsjson11_deserializeOpDocumentPollForThirdPartyJobsOutput(v **PollForThirdPartyJobsOutput, value interface{}) error { 12862 if v == nil { 12863 return fmt.Errorf("unexpected nil of type %T", v) 12864 } 12865 if value == nil { 12866 return nil 12867 } 12868 12869 shape, ok := value.(map[string]interface{}) 12870 if !ok { 12871 return fmt.Errorf("unexpected JSON type %v", value) 12872 } 12873 12874 var sv *PollForThirdPartyJobsOutput 12875 if *v == nil { 12876 sv = &PollForThirdPartyJobsOutput{} 12877 } else { 12878 sv = *v 12879 } 12880 12881 for key, value := range shape { 12882 switch key { 12883 case "jobs": 12884 if err := awsAwsjson11_deserializeDocumentThirdPartyJobList(&sv.Jobs, value); err != nil { 12885 return err 12886 } 12887 12888 default: 12889 _, _ = key, value 12890 12891 } 12892 } 12893 *v = sv 12894 return nil 12895} 12896 12897func awsAwsjson11_deserializeOpDocumentPutActionRevisionOutput(v **PutActionRevisionOutput, value interface{}) error { 12898 if v == nil { 12899 return fmt.Errorf("unexpected nil of type %T", v) 12900 } 12901 if value == nil { 12902 return nil 12903 } 12904 12905 shape, ok := value.(map[string]interface{}) 12906 if !ok { 12907 return fmt.Errorf("unexpected JSON type %v", value) 12908 } 12909 12910 var sv *PutActionRevisionOutput 12911 if *v == nil { 12912 sv = &PutActionRevisionOutput{} 12913 } else { 12914 sv = *v 12915 } 12916 12917 for key, value := range shape { 12918 switch key { 12919 case "newRevision": 12920 if value != nil { 12921 jtv, ok := value.(bool) 12922 if !ok { 12923 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 12924 } 12925 sv.NewRevision = jtv 12926 } 12927 12928 case "pipelineExecutionId": 12929 if value != nil { 12930 jtv, ok := value.(string) 12931 if !ok { 12932 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 12933 } 12934 sv.PipelineExecutionId = ptr.String(jtv) 12935 } 12936 12937 default: 12938 _, _ = key, value 12939 12940 } 12941 } 12942 *v = sv 12943 return nil 12944} 12945 12946func awsAwsjson11_deserializeOpDocumentPutApprovalResultOutput(v **PutApprovalResultOutput, value interface{}) error { 12947 if v == nil { 12948 return fmt.Errorf("unexpected nil of type %T", v) 12949 } 12950 if value == nil { 12951 return nil 12952 } 12953 12954 shape, ok := value.(map[string]interface{}) 12955 if !ok { 12956 return fmt.Errorf("unexpected JSON type %v", value) 12957 } 12958 12959 var sv *PutApprovalResultOutput 12960 if *v == nil { 12961 sv = &PutApprovalResultOutput{} 12962 } else { 12963 sv = *v 12964 } 12965 12966 for key, value := range shape { 12967 switch key { 12968 case "approvedAt": 12969 if value != nil { 12970 jtv, ok := value.(json.Number) 12971 if !ok { 12972 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 12973 } 12974 f64, err := jtv.Float64() 12975 if err != nil { 12976 return err 12977 } 12978 sv.ApprovedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12979 } 12980 12981 default: 12982 _, _ = key, value 12983 12984 } 12985 } 12986 *v = sv 12987 return nil 12988} 12989 12990func awsAwsjson11_deserializeOpDocumentPutWebhookOutput(v **PutWebhookOutput, value interface{}) error { 12991 if v == nil { 12992 return fmt.Errorf("unexpected nil of type %T", v) 12993 } 12994 if value == nil { 12995 return nil 12996 } 12997 12998 shape, ok := value.(map[string]interface{}) 12999 if !ok { 13000 return fmt.Errorf("unexpected JSON type %v", value) 13001 } 13002 13003 var sv *PutWebhookOutput 13004 if *v == nil { 13005 sv = &PutWebhookOutput{} 13006 } else { 13007 sv = *v 13008 } 13009 13010 for key, value := range shape { 13011 switch key { 13012 case "webhook": 13013 if err := awsAwsjson11_deserializeDocumentListWebhookItem(&sv.Webhook, value); err != nil { 13014 return err 13015 } 13016 13017 default: 13018 _, _ = key, value 13019 13020 } 13021 } 13022 *v = sv 13023 return nil 13024} 13025 13026func awsAwsjson11_deserializeOpDocumentRegisterWebhookWithThirdPartyOutput(v **RegisterWebhookWithThirdPartyOutput, value interface{}) error { 13027 if v == nil { 13028 return fmt.Errorf("unexpected nil of type %T", v) 13029 } 13030 if value == nil { 13031 return nil 13032 } 13033 13034 shape, ok := value.(map[string]interface{}) 13035 if !ok { 13036 return fmt.Errorf("unexpected JSON type %v", value) 13037 } 13038 13039 var sv *RegisterWebhookWithThirdPartyOutput 13040 if *v == nil { 13041 sv = &RegisterWebhookWithThirdPartyOutput{} 13042 } else { 13043 sv = *v 13044 } 13045 13046 for key, value := range shape { 13047 switch key { 13048 default: 13049 _, _ = key, value 13050 13051 } 13052 } 13053 *v = sv 13054 return nil 13055} 13056 13057func awsAwsjson11_deserializeOpDocumentRetryStageExecutionOutput(v **RetryStageExecutionOutput, value interface{}) error { 13058 if v == nil { 13059 return fmt.Errorf("unexpected nil of type %T", v) 13060 } 13061 if value == nil { 13062 return nil 13063 } 13064 13065 shape, ok := value.(map[string]interface{}) 13066 if !ok { 13067 return fmt.Errorf("unexpected JSON type %v", value) 13068 } 13069 13070 var sv *RetryStageExecutionOutput 13071 if *v == nil { 13072 sv = &RetryStageExecutionOutput{} 13073 } else { 13074 sv = *v 13075 } 13076 13077 for key, value := range shape { 13078 switch key { 13079 case "pipelineExecutionId": 13080 if value != nil { 13081 jtv, ok := value.(string) 13082 if !ok { 13083 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 13084 } 13085 sv.PipelineExecutionId = ptr.String(jtv) 13086 } 13087 13088 default: 13089 _, _ = key, value 13090 13091 } 13092 } 13093 *v = sv 13094 return nil 13095} 13096 13097func awsAwsjson11_deserializeOpDocumentStartPipelineExecutionOutput(v **StartPipelineExecutionOutput, value interface{}) error { 13098 if v == nil { 13099 return fmt.Errorf("unexpected nil of type %T", v) 13100 } 13101 if value == nil { 13102 return nil 13103 } 13104 13105 shape, ok := value.(map[string]interface{}) 13106 if !ok { 13107 return fmt.Errorf("unexpected JSON type %v", value) 13108 } 13109 13110 var sv *StartPipelineExecutionOutput 13111 if *v == nil { 13112 sv = &StartPipelineExecutionOutput{} 13113 } else { 13114 sv = *v 13115 } 13116 13117 for key, value := range shape { 13118 switch key { 13119 case "pipelineExecutionId": 13120 if value != nil { 13121 jtv, ok := value.(string) 13122 if !ok { 13123 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 13124 } 13125 sv.PipelineExecutionId = ptr.String(jtv) 13126 } 13127 13128 default: 13129 _, _ = key, value 13130 13131 } 13132 } 13133 *v = sv 13134 return nil 13135} 13136 13137func awsAwsjson11_deserializeOpDocumentStopPipelineExecutionOutput(v **StopPipelineExecutionOutput, value interface{}) error { 13138 if v == nil { 13139 return fmt.Errorf("unexpected nil of type %T", v) 13140 } 13141 if value == nil { 13142 return nil 13143 } 13144 13145 shape, ok := value.(map[string]interface{}) 13146 if !ok { 13147 return fmt.Errorf("unexpected JSON type %v", value) 13148 } 13149 13150 var sv *StopPipelineExecutionOutput 13151 if *v == nil { 13152 sv = &StopPipelineExecutionOutput{} 13153 } else { 13154 sv = *v 13155 } 13156 13157 for key, value := range shape { 13158 switch key { 13159 case "pipelineExecutionId": 13160 if value != nil { 13161 jtv, ok := value.(string) 13162 if !ok { 13163 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 13164 } 13165 sv.PipelineExecutionId = ptr.String(jtv) 13166 } 13167 13168 default: 13169 _, _ = key, value 13170 13171 } 13172 } 13173 *v = sv 13174 return nil 13175} 13176 13177func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error { 13178 if v == nil { 13179 return fmt.Errorf("unexpected nil of type %T", v) 13180 } 13181 if value == nil { 13182 return nil 13183 } 13184 13185 shape, ok := value.(map[string]interface{}) 13186 if !ok { 13187 return fmt.Errorf("unexpected JSON type %v", value) 13188 } 13189 13190 var sv *TagResourceOutput 13191 if *v == nil { 13192 sv = &TagResourceOutput{} 13193 } else { 13194 sv = *v 13195 } 13196 13197 for key, value := range shape { 13198 switch key { 13199 default: 13200 _, _ = key, value 13201 13202 } 13203 } 13204 *v = sv 13205 return nil 13206} 13207 13208func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error { 13209 if v == nil { 13210 return fmt.Errorf("unexpected nil of type %T", v) 13211 } 13212 if value == nil { 13213 return nil 13214 } 13215 13216 shape, ok := value.(map[string]interface{}) 13217 if !ok { 13218 return fmt.Errorf("unexpected JSON type %v", value) 13219 } 13220 13221 var sv *UntagResourceOutput 13222 if *v == nil { 13223 sv = &UntagResourceOutput{} 13224 } else { 13225 sv = *v 13226 } 13227 13228 for key, value := range shape { 13229 switch key { 13230 default: 13231 _, _ = key, value 13232 13233 } 13234 } 13235 *v = sv 13236 return nil 13237} 13238 13239func awsAwsjson11_deserializeOpDocumentUpdatePipelineOutput(v **UpdatePipelineOutput, value interface{}) error { 13240 if v == nil { 13241 return fmt.Errorf("unexpected nil of type %T", v) 13242 } 13243 if value == nil { 13244 return nil 13245 } 13246 13247 shape, ok := value.(map[string]interface{}) 13248 if !ok { 13249 return fmt.Errorf("unexpected JSON type %v", value) 13250 } 13251 13252 var sv *UpdatePipelineOutput 13253 if *v == nil { 13254 sv = &UpdatePipelineOutput{} 13255 } else { 13256 sv = *v 13257 } 13258 13259 for key, value := range shape { 13260 switch key { 13261 case "pipeline": 13262 if err := awsAwsjson11_deserializeDocumentPipelineDeclaration(&sv.Pipeline, value); err != nil { 13263 return err 13264 } 13265 13266 default: 13267 _, _ = key, value 13268 13269 } 13270 } 13271 *v = sv 13272 return nil 13273} 13274