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_deserializeOpGetJobDetails struct { 1124} 1125 1126func (*awsAwsjson11_deserializeOpGetJobDetails) ID() string { 1127 return "OperationDeserializer" 1128} 1129 1130func (m *awsAwsjson11_deserializeOpGetJobDetails) 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_deserializeOpErrorGetJobDetails(response, &metadata) 1145 } 1146 output := &GetJobDetailsOutput{} 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_deserializeOpDocumentGetJobDetailsOutput(&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_deserializeOpErrorGetJobDetails(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("JobNotFoundException", errorCode): 1222 return awsAwsjson11_deserializeErrorJobNotFoundException(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_deserializeOpGetPipeline struct { 1238} 1239 1240func (*awsAwsjson11_deserializeOpGetPipeline) ID() string { 1241 return "OperationDeserializer" 1242} 1243 1244func (m *awsAwsjson11_deserializeOpGetPipeline) 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_deserializeOpErrorGetPipeline(response, &metadata) 1259 } 1260 output := &GetPipelineOutput{} 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_deserializeOpDocumentGetPipelineOutput(&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_deserializeOpErrorGetPipeline(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("PipelineNotFoundException", errorCode): 1336 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 1337 1338 case strings.EqualFold("PipelineVersionNotFoundException", errorCode): 1339 return awsAwsjson11_deserializeErrorPipelineVersionNotFoundException(response, errorBody) 1340 1341 case strings.EqualFold("ValidationException", errorCode): 1342 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1343 1344 default: 1345 genericError := &smithy.GenericAPIError{ 1346 Code: errorCode, 1347 Message: errorMessage, 1348 } 1349 return genericError 1350 1351 } 1352} 1353 1354type awsAwsjson11_deserializeOpGetPipelineExecution struct { 1355} 1356 1357func (*awsAwsjson11_deserializeOpGetPipelineExecution) ID() string { 1358 return "OperationDeserializer" 1359} 1360 1361func (m *awsAwsjson11_deserializeOpGetPipelineExecution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1362 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1363) { 1364 out, metadata, err = next.HandleDeserialize(ctx, in) 1365 if err != nil { 1366 return out, metadata, err 1367 } 1368 1369 response, ok := out.RawResponse.(*smithyhttp.Response) 1370 if !ok { 1371 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1372 } 1373 1374 if response.StatusCode < 200 || response.StatusCode >= 300 { 1375 return out, metadata, awsAwsjson11_deserializeOpErrorGetPipelineExecution(response, &metadata) 1376 } 1377 output := &GetPipelineExecutionOutput{} 1378 out.Result = output 1379 1380 var buff [1024]byte 1381 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1382 1383 body := io.TeeReader(response.Body, ringBuffer) 1384 decoder := json.NewDecoder(body) 1385 decoder.UseNumber() 1386 var shape interface{} 1387 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1388 var snapshot bytes.Buffer 1389 io.Copy(&snapshot, ringBuffer) 1390 err = &smithy.DeserializationError{ 1391 Err: fmt.Errorf("failed to decode response body, %w", err), 1392 Snapshot: snapshot.Bytes(), 1393 } 1394 return out, metadata, err 1395 } 1396 1397 err = awsAwsjson11_deserializeOpDocumentGetPipelineExecutionOutput(&output, shape) 1398 if err != nil { 1399 var snapshot bytes.Buffer 1400 io.Copy(&snapshot, ringBuffer) 1401 err = &smithy.DeserializationError{ 1402 Err: fmt.Errorf("failed to decode response body, %w", err), 1403 Snapshot: snapshot.Bytes(), 1404 } 1405 return out, metadata, err 1406 } 1407 1408 return out, metadata, err 1409} 1410 1411func awsAwsjson11_deserializeOpErrorGetPipelineExecution(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1412 var errorBuffer bytes.Buffer 1413 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1414 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1415 } 1416 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1417 1418 errorCode := "UnknownError" 1419 errorMessage := errorCode 1420 1421 code := response.Header.Get("X-Amzn-ErrorType") 1422 if len(code) != 0 { 1423 errorCode = restjson.SanitizeErrorCode(code) 1424 } 1425 1426 var buff [1024]byte 1427 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1428 1429 body := io.TeeReader(errorBody, ringBuffer) 1430 decoder := json.NewDecoder(body) 1431 decoder.UseNumber() 1432 code, message, err := restjson.GetErrorInfo(decoder) 1433 if err != nil { 1434 var snapshot bytes.Buffer 1435 io.Copy(&snapshot, ringBuffer) 1436 err = &smithy.DeserializationError{ 1437 Err: fmt.Errorf("failed to decode response body, %w", err), 1438 Snapshot: snapshot.Bytes(), 1439 } 1440 return err 1441 } 1442 1443 errorBody.Seek(0, io.SeekStart) 1444 if len(code) != 0 { 1445 errorCode = restjson.SanitizeErrorCode(code) 1446 } 1447 if len(message) != 0 { 1448 errorMessage = message 1449 } 1450 1451 switch { 1452 case strings.EqualFold("PipelineExecutionNotFoundException", errorCode): 1453 return awsAwsjson11_deserializeErrorPipelineExecutionNotFoundException(response, errorBody) 1454 1455 case strings.EqualFold("PipelineNotFoundException", errorCode): 1456 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 1457 1458 case strings.EqualFold("ValidationException", errorCode): 1459 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1460 1461 default: 1462 genericError := &smithy.GenericAPIError{ 1463 Code: errorCode, 1464 Message: errorMessage, 1465 } 1466 return genericError 1467 1468 } 1469} 1470 1471type awsAwsjson11_deserializeOpGetPipelineState struct { 1472} 1473 1474func (*awsAwsjson11_deserializeOpGetPipelineState) ID() string { 1475 return "OperationDeserializer" 1476} 1477 1478func (m *awsAwsjson11_deserializeOpGetPipelineState) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1479 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1480) { 1481 out, metadata, err = next.HandleDeserialize(ctx, in) 1482 if err != nil { 1483 return out, metadata, err 1484 } 1485 1486 response, ok := out.RawResponse.(*smithyhttp.Response) 1487 if !ok { 1488 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1489 } 1490 1491 if response.StatusCode < 200 || response.StatusCode >= 300 { 1492 return out, metadata, awsAwsjson11_deserializeOpErrorGetPipelineState(response, &metadata) 1493 } 1494 output := &GetPipelineStateOutput{} 1495 out.Result = output 1496 1497 var buff [1024]byte 1498 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1499 1500 body := io.TeeReader(response.Body, ringBuffer) 1501 decoder := json.NewDecoder(body) 1502 decoder.UseNumber() 1503 var shape interface{} 1504 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1505 var snapshot bytes.Buffer 1506 io.Copy(&snapshot, ringBuffer) 1507 err = &smithy.DeserializationError{ 1508 Err: fmt.Errorf("failed to decode response body, %w", err), 1509 Snapshot: snapshot.Bytes(), 1510 } 1511 return out, metadata, err 1512 } 1513 1514 err = awsAwsjson11_deserializeOpDocumentGetPipelineStateOutput(&output, shape) 1515 if err != nil { 1516 var snapshot bytes.Buffer 1517 io.Copy(&snapshot, ringBuffer) 1518 err = &smithy.DeserializationError{ 1519 Err: fmt.Errorf("failed to decode response body, %w", err), 1520 Snapshot: snapshot.Bytes(), 1521 } 1522 return out, metadata, err 1523 } 1524 1525 return out, metadata, err 1526} 1527 1528func awsAwsjson11_deserializeOpErrorGetPipelineState(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1529 var errorBuffer bytes.Buffer 1530 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1531 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1532 } 1533 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1534 1535 errorCode := "UnknownError" 1536 errorMessage := errorCode 1537 1538 code := response.Header.Get("X-Amzn-ErrorType") 1539 if len(code) != 0 { 1540 errorCode = restjson.SanitizeErrorCode(code) 1541 } 1542 1543 var buff [1024]byte 1544 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1545 1546 body := io.TeeReader(errorBody, ringBuffer) 1547 decoder := json.NewDecoder(body) 1548 decoder.UseNumber() 1549 code, message, err := restjson.GetErrorInfo(decoder) 1550 if err != nil { 1551 var snapshot bytes.Buffer 1552 io.Copy(&snapshot, ringBuffer) 1553 err = &smithy.DeserializationError{ 1554 Err: fmt.Errorf("failed to decode response body, %w", err), 1555 Snapshot: snapshot.Bytes(), 1556 } 1557 return err 1558 } 1559 1560 errorBody.Seek(0, io.SeekStart) 1561 if len(code) != 0 { 1562 errorCode = restjson.SanitizeErrorCode(code) 1563 } 1564 if len(message) != 0 { 1565 errorMessage = message 1566 } 1567 1568 switch { 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_deserializeOpGetThirdPartyJobDetails struct { 1586} 1587 1588func (*awsAwsjson11_deserializeOpGetThirdPartyJobDetails) ID() string { 1589 return "OperationDeserializer" 1590} 1591 1592func (m *awsAwsjson11_deserializeOpGetThirdPartyJobDetails) 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_deserializeOpErrorGetThirdPartyJobDetails(response, &metadata) 1607 } 1608 output := &GetThirdPartyJobDetailsOutput{} 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_deserializeOpDocumentGetThirdPartyJobDetailsOutput(&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_deserializeOpErrorGetThirdPartyJobDetails(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("InvalidClientTokenException", errorCode): 1684 return awsAwsjson11_deserializeErrorInvalidClientTokenException(response, errorBody) 1685 1686 case strings.EqualFold("InvalidJobException", errorCode): 1687 return awsAwsjson11_deserializeErrorInvalidJobException(response, errorBody) 1688 1689 case strings.EqualFold("JobNotFoundException", errorCode): 1690 return awsAwsjson11_deserializeErrorJobNotFoundException(response, errorBody) 1691 1692 case strings.EqualFold("ValidationException", errorCode): 1693 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1694 1695 default: 1696 genericError := &smithy.GenericAPIError{ 1697 Code: errorCode, 1698 Message: errorMessage, 1699 } 1700 return genericError 1701 1702 } 1703} 1704 1705type awsAwsjson11_deserializeOpListActionExecutions struct { 1706} 1707 1708func (*awsAwsjson11_deserializeOpListActionExecutions) ID() string { 1709 return "OperationDeserializer" 1710} 1711 1712func (m *awsAwsjson11_deserializeOpListActionExecutions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1713 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1714) { 1715 out, metadata, err = next.HandleDeserialize(ctx, in) 1716 if err != nil { 1717 return out, metadata, err 1718 } 1719 1720 response, ok := out.RawResponse.(*smithyhttp.Response) 1721 if !ok { 1722 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1723 } 1724 1725 if response.StatusCode < 200 || response.StatusCode >= 300 { 1726 return out, metadata, awsAwsjson11_deserializeOpErrorListActionExecutions(response, &metadata) 1727 } 1728 output := &ListActionExecutionsOutput{} 1729 out.Result = output 1730 1731 var buff [1024]byte 1732 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1733 1734 body := io.TeeReader(response.Body, ringBuffer) 1735 decoder := json.NewDecoder(body) 1736 decoder.UseNumber() 1737 var shape interface{} 1738 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1739 var snapshot bytes.Buffer 1740 io.Copy(&snapshot, ringBuffer) 1741 err = &smithy.DeserializationError{ 1742 Err: fmt.Errorf("failed to decode response body, %w", err), 1743 Snapshot: snapshot.Bytes(), 1744 } 1745 return out, metadata, err 1746 } 1747 1748 err = awsAwsjson11_deserializeOpDocumentListActionExecutionsOutput(&output, shape) 1749 if err != nil { 1750 var snapshot bytes.Buffer 1751 io.Copy(&snapshot, ringBuffer) 1752 err = &smithy.DeserializationError{ 1753 Err: fmt.Errorf("failed to decode response body, %w", err), 1754 Snapshot: snapshot.Bytes(), 1755 } 1756 return out, metadata, err 1757 } 1758 1759 return out, metadata, err 1760} 1761 1762func awsAwsjson11_deserializeOpErrorListActionExecutions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1763 var errorBuffer bytes.Buffer 1764 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1765 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1766 } 1767 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1768 1769 errorCode := "UnknownError" 1770 errorMessage := errorCode 1771 1772 code := response.Header.Get("X-Amzn-ErrorType") 1773 if len(code) != 0 { 1774 errorCode = restjson.SanitizeErrorCode(code) 1775 } 1776 1777 var buff [1024]byte 1778 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1779 1780 body := io.TeeReader(errorBody, ringBuffer) 1781 decoder := json.NewDecoder(body) 1782 decoder.UseNumber() 1783 code, message, err := restjson.GetErrorInfo(decoder) 1784 if err != nil { 1785 var snapshot bytes.Buffer 1786 io.Copy(&snapshot, ringBuffer) 1787 err = &smithy.DeserializationError{ 1788 Err: fmt.Errorf("failed to decode response body, %w", err), 1789 Snapshot: snapshot.Bytes(), 1790 } 1791 return err 1792 } 1793 1794 errorBody.Seek(0, io.SeekStart) 1795 if len(code) != 0 { 1796 errorCode = restjson.SanitizeErrorCode(code) 1797 } 1798 if len(message) != 0 { 1799 errorMessage = message 1800 } 1801 1802 switch { 1803 case strings.EqualFold("InvalidNextTokenException", errorCode): 1804 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 1805 1806 case strings.EqualFold("PipelineExecutionNotFoundException", errorCode): 1807 return awsAwsjson11_deserializeErrorPipelineExecutionNotFoundException(response, errorBody) 1808 1809 case strings.EqualFold("PipelineNotFoundException", errorCode): 1810 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 1811 1812 case strings.EqualFold("ValidationException", errorCode): 1813 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1814 1815 default: 1816 genericError := &smithy.GenericAPIError{ 1817 Code: errorCode, 1818 Message: errorMessage, 1819 } 1820 return genericError 1821 1822 } 1823} 1824 1825type awsAwsjson11_deserializeOpListActionTypes struct { 1826} 1827 1828func (*awsAwsjson11_deserializeOpListActionTypes) ID() string { 1829 return "OperationDeserializer" 1830} 1831 1832func (m *awsAwsjson11_deserializeOpListActionTypes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1833 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1834) { 1835 out, metadata, err = next.HandleDeserialize(ctx, in) 1836 if err != nil { 1837 return out, metadata, err 1838 } 1839 1840 response, ok := out.RawResponse.(*smithyhttp.Response) 1841 if !ok { 1842 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1843 } 1844 1845 if response.StatusCode < 200 || response.StatusCode >= 300 { 1846 return out, metadata, awsAwsjson11_deserializeOpErrorListActionTypes(response, &metadata) 1847 } 1848 output := &ListActionTypesOutput{} 1849 out.Result = output 1850 1851 var buff [1024]byte 1852 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1853 1854 body := io.TeeReader(response.Body, ringBuffer) 1855 decoder := json.NewDecoder(body) 1856 decoder.UseNumber() 1857 var shape interface{} 1858 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1859 var snapshot bytes.Buffer 1860 io.Copy(&snapshot, ringBuffer) 1861 err = &smithy.DeserializationError{ 1862 Err: fmt.Errorf("failed to decode response body, %w", err), 1863 Snapshot: snapshot.Bytes(), 1864 } 1865 return out, metadata, err 1866 } 1867 1868 err = awsAwsjson11_deserializeOpDocumentListActionTypesOutput(&output, shape) 1869 if err != nil { 1870 var snapshot bytes.Buffer 1871 io.Copy(&snapshot, ringBuffer) 1872 err = &smithy.DeserializationError{ 1873 Err: fmt.Errorf("failed to decode response body, %w", err), 1874 Snapshot: snapshot.Bytes(), 1875 } 1876 return out, metadata, err 1877 } 1878 1879 return out, metadata, err 1880} 1881 1882func awsAwsjson11_deserializeOpErrorListActionTypes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1883 var errorBuffer bytes.Buffer 1884 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1885 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1886 } 1887 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1888 1889 errorCode := "UnknownError" 1890 errorMessage := errorCode 1891 1892 code := response.Header.Get("X-Amzn-ErrorType") 1893 if len(code) != 0 { 1894 errorCode = restjson.SanitizeErrorCode(code) 1895 } 1896 1897 var buff [1024]byte 1898 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1899 1900 body := io.TeeReader(errorBody, ringBuffer) 1901 decoder := json.NewDecoder(body) 1902 decoder.UseNumber() 1903 code, message, err := restjson.GetErrorInfo(decoder) 1904 if err != nil { 1905 var snapshot bytes.Buffer 1906 io.Copy(&snapshot, ringBuffer) 1907 err = &smithy.DeserializationError{ 1908 Err: fmt.Errorf("failed to decode response body, %w", err), 1909 Snapshot: snapshot.Bytes(), 1910 } 1911 return err 1912 } 1913 1914 errorBody.Seek(0, io.SeekStart) 1915 if len(code) != 0 { 1916 errorCode = restjson.SanitizeErrorCode(code) 1917 } 1918 if len(message) != 0 { 1919 errorMessage = message 1920 } 1921 1922 switch { 1923 case strings.EqualFold("InvalidNextTokenException", errorCode): 1924 return awsAwsjson11_deserializeErrorInvalidNextTokenException(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_deserializeOpListPipelineExecutions struct { 1940} 1941 1942func (*awsAwsjson11_deserializeOpListPipelineExecutions) ID() string { 1943 return "OperationDeserializer" 1944} 1945 1946func (m *awsAwsjson11_deserializeOpListPipelineExecutions) 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_deserializeOpErrorListPipelineExecutions(response, &metadata) 1961 } 1962 output := &ListPipelineExecutionsOutput{} 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_deserializeOpDocumentListPipelineExecutionsOutput(&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_deserializeOpErrorListPipelineExecutions(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("PipelineNotFoundException", errorCode): 2041 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 2042 2043 case strings.EqualFold("ValidationException", errorCode): 2044 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2045 2046 default: 2047 genericError := &smithy.GenericAPIError{ 2048 Code: errorCode, 2049 Message: errorMessage, 2050 } 2051 return genericError 2052 2053 } 2054} 2055 2056type awsAwsjson11_deserializeOpListPipelines struct { 2057} 2058 2059func (*awsAwsjson11_deserializeOpListPipelines) ID() string { 2060 return "OperationDeserializer" 2061} 2062 2063func (m *awsAwsjson11_deserializeOpListPipelines) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2064 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2065) { 2066 out, metadata, err = next.HandleDeserialize(ctx, in) 2067 if err != nil { 2068 return out, metadata, err 2069 } 2070 2071 response, ok := out.RawResponse.(*smithyhttp.Response) 2072 if !ok { 2073 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2074 } 2075 2076 if response.StatusCode < 200 || response.StatusCode >= 300 { 2077 return out, metadata, awsAwsjson11_deserializeOpErrorListPipelines(response, &metadata) 2078 } 2079 output := &ListPipelinesOutput{} 2080 out.Result = output 2081 2082 var buff [1024]byte 2083 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2084 2085 body := io.TeeReader(response.Body, ringBuffer) 2086 decoder := json.NewDecoder(body) 2087 decoder.UseNumber() 2088 var shape interface{} 2089 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2090 var snapshot bytes.Buffer 2091 io.Copy(&snapshot, ringBuffer) 2092 err = &smithy.DeserializationError{ 2093 Err: fmt.Errorf("failed to decode response body, %w", err), 2094 Snapshot: snapshot.Bytes(), 2095 } 2096 return out, metadata, err 2097 } 2098 2099 err = awsAwsjson11_deserializeOpDocumentListPipelinesOutput(&output, shape) 2100 if err != nil { 2101 var snapshot bytes.Buffer 2102 io.Copy(&snapshot, ringBuffer) 2103 err = &smithy.DeserializationError{ 2104 Err: fmt.Errorf("failed to decode response body, %w", err), 2105 Snapshot: snapshot.Bytes(), 2106 } 2107 return out, metadata, err 2108 } 2109 2110 return out, metadata, err 2111} 2112 2113func awsAwsjson11_deserializeOpErrorListPipelines(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2114 var errorBuffer bytes.Buffer 2115 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2116 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2117 } 2118 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2119 2120 errorCode := "UnknownError" 2121 errorMessage := errorCode 2122 2123 code := response.Header.Get("X-Amzn-ErrorType") 2124 if len(code) != 0 { 2125 errorCode = restjson.SanitizeErrorCode(code) 2126 } 2127 2128 var buff [1024]byte 2129 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2130 2131 body := io.TeeReader(errorBody, ringBuffer) 2132 decoder := json.NewDecoder(body) 2133 decoder.UseNumber() 2134 code, message, err := restjson.GetErrorInfo(decoder) 2135 if err != nil { 2136 var snapshot bytes.Buffer 2137 io.Copy(&snapshot, ringBuffer) 2138 err = &smithy.DeserializationError{ 2139 Err: fmt.Errorf("failed to decode response body, %w", err), 2140 Snapshot: snapshot.Bytes(), 2141 } 2142 return err 2143 } 2144 2145 errorBody.Seek(0, io.SeekStart) 2146 if len(code) != 0 { 2147 errorCode = restjson.SanitizeErrorCode(code) 2148 } 2149 if len(message) != 0 { 2150 errorMessage = message 2151 } 2152 2153 switch { 2154 case strings.EqualFold("InvalidNextTokenException", errorCode): 2155 return awsAwsjson11_deserializeErrorInvalidNextTokenException(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_deserializeOpListTagsForResource struct { 2171} 2172 2173func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string { 2174 return "OperationDeserializer" 2175} 2176 2177func (m *awsAwsjson11_deserializeOpListTagsForResource) 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_deserializeOpErrorListTagsForResource(response, &metadata) 2192 } 2193 output := &ListTagsForResourceOutput{} 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_deserializeOpDocumentListTagsForResourceOutput(&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_deserializeOpErrorListTagsForResource(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("InvalidArnException", errorCode): 2269 return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) 2270 2271 case strings.EqualFold("InvalidNextTokenException", errorCode): 2272 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 2273 2274 case strings.EqualFold("ResourceNotFoundException", errorCode): 2275 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2276 2277 case strings.EqualFold("ValidationException", errorCode): 2278 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2279 2280 default: 2281 genericError := &smithy.GenericAPIError{ 2282 Code: errorCode, 2283 Message: errorMessage, 2284 } 2285 return genericError 2286 2287 } 2288} 2289 2290type awsAwsjson11_deserializeOpListWebhooks struct { 2291} 2292 2293func (*awsAwsjson11_deserializeOpListWebhooks) ID() string { 2294 return "OperationDeserializer" 2295} 2296 2297func (m *awsAwsjson11_deserializeOpListWebhooks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2298 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2299) { 2300 out, metadata, err = next.HandleDeserialize(ctx, in) 2301 if err != nil { 2302 return out, metadata, err 2303 } 2304 2305 response, ok := out.RawResponse.(*smithyhttp.Response) 2306 if !ok { 2307 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2308 } 2309 2310 if response.StatusCode < 200 || response.StatusCode >= 300 { 2311 return out, metadata, awsAwsjson11_deserializeOpErrorListWebhooks(response, &metadata) 2312 } 2313 output := &ListWebhooksOutput{} 2314 out.Result = output 2315 2316 var buff [1024]byte 2317 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2318 2319 body := io.TeeReader(response.Body, ringBuffer) 2320 decoder := json.NewDecoder(body) 2321 decoder.UseNumber() 2322 var shape interface{} 2323 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2324 var snapshot bytes.Buffer 2325 io.Copy(&snapshot, ringBuffer) 2326 err = &smithy.DeserializationError{ 2327 Err: fmt.Errorf("failed to decode response body, %w", err), 2328 Snapshot: snapshot.Bytes(), 2329 } 2330 return out, metadata, err 2331 } 2332 2333 err = awsAwsjson11_deserializeOpDocumentListWebhooksOutput(&output, shape) 2334 if err != nil { 2335 var snapshot bytes.Buffer 2336 io.Copy(&snapshot, ringBuffer) 2337 err = &smithy.DeserializationError{ 2338 Err: fmt.Errorf("failed to decode response body, %w", err), 2339 Snapshot: snapshot.Bytes(), 2340 } 2341 return out, metadata, err 2342 } 2343 2344 return out, metadata, err 2345} 2346 2347func awsAwsjson11_deserializeOpErrorListWebhooks(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2348 var errorBuffer bytes.Buffer 2349 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2350 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2351 } 2352 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2353 2354 errorCode := "UnknownError" 2355 errorMessage := errorCode 2356 2357 code := response.Header.Get("X-Amzn-ErrorType") 2358 if len(code) != 0 { 2359 errorCode = restjson.SanitizeErrorCode(code) 2360 } 2361 2362 var buff [1024]byte 2363 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2364 2365 body := io.TeeReader(errorBody, ringBuffer) 2366 decoder := json.NewDecoder(body) 2367 decoder.UseNumber() 2368 code, message, err := restjson.GetErrorInfo(decoder) 2369 if err != nil { 2370 var snapshot bytes.Buffer 2371 io.Copy(&snapshot, ringBuffer) 2372 err = &smithy.DeserializationError{ 2373 Err: fmt.Errorf("failed to decode response body, %w", err), 2374 Snapshot: snapshot.Bytes(), 2375 } 2376 return err 2377 } 2378 2379 errorBody.Seek(0, io.SeekStart) 2380 if len(code) != 0 { 2381 errorCode = restjson.SanitizeErrorCode(code) 2382 } 2383 if len(message) != 0 { 2384 errorMessage = message 2385 } 2386 2387 switch { 2388 case strings.EqualFold("InvalidNextTokenException", errorCode): 2389 return awsAwsjson11_deserializeErrorInvalidNextTokenException(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_deserializeOpPollForJobs struct { 2405} 2406 2407func (*awsAwsjson11_deserializeOpPollForJobs) ID() string { 2408 return "OperationDeserializer" 2409} 2410 2411func (m *awsAwsjson11_deserializeOpPollForJobs) 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_deserializeOpErrorPollForJobs(response, &metadata) 2426 } 2427 output := &PollForJobsOutput{} 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_deserializeOpDocumentPollForJobsOutput(&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_deserializeOpErrorPollForJobs(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("ActionTypeNotFoundException", errorCode): 2503 return awsAwsjson11_deserializeErrorActionTypeNotFoundException(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_deserializeOpPollForThirdPartyJobs struct { 2519} 2520 2521func (*awsAwsjson11_deserializeOpPollForThirdPartyJobs) ID() string { 2522 return "OperationDeserializer" 2523} 2524 2525func (m *awsAwsjson11_deserializeOpPollForThirdPartyJobs) 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_deserializeOpErrorPollForThirdPartyJobs(response, &metadata) 2540 } 2541 output := &PollForThirdPartyJobsOutput{} 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_deserializeOpDocumentPollForThirdPartyJobsOutput(&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_deserializeOpErrorPollForThirdPartyJobs(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_deserializeOpPutActionRevision struct { 2633} 2634 2635func (*awsAwsjson11_deserializeOpPutActionRevision) ID() string { 2636 return "OperationDeserializer" 2637} 2638 2639func (m *awsAwsjson11_deserializeOpPutActionRevision) 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_deserializeOpErrorPutActionRevision(response, &metadata) 2654 } 2655 output := &PutActionRevisionOutput{} 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_deserializeOpDocumentPutActionRevisionOutput(&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_deserializeOpErrorPutActionRevision(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("ActionNotFoundException", errorCode): 2731 return awsAwsjson11_deserializeErrorActionNotFoundException(response, errorBody) 2732 2733 case strings.EqualFold("PipelineNotFoundException", errorCode): 2734 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 2735 2736 case strings.EqualFold("StageNotFoundException", errorCode): 2737 return awsAwsjson11_deserializeErrorStageNotFoundException(response, errorBody) 2738 2739 case strings.EqualFold("ValidationException", errorCode): 2740 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2741 2742 default: 2743 genericError := &smithy.GenericAPIError{ 2744 Code: errorCode, 2745 Message: errorMessage, 2746 } 2747 return genericError 2748 2749 } 2750} 2751 2752type awsAwsjson11_deserializeOpPutApprovalResult struct { 2753} 2754 2755func (*awsAwsjson11_deserializeOpPutApprovalResult) ID() string { 2756 return "OperationDeserializer" 2757} 2758 2759func (m *awsAwsjson11_deserializeOpPutApprovalResult) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2760 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2761) { 2762 out, metadata, err = next.HandleDeserialize(ctx, in) 2763 if err != nil { 2764 return out, metadata, err 2765 } 2766 2767 response, ok := out.RawResponse.(*smithyhttp.Response) 2768 if !ok { 2769 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2770 } 2771 2772 if response.StatusCode < 200 || response.StatusCode >= 300 { 2773 return out, metadata, awsAwsjson11_deserializeOpErrorPutApprovalResult(response, &metadata) 2774 } 2775 output := &PutApprovalResultOutput{} 2776 out.Result = output 2777 2778 var buff [1024]byte 2779 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2780 2781 body := io.TeeReader(response.Body, ringBuffer) 2782 decoder := json.NewDecoder(body) 2783 decoder.UseNumber() 2784 var shape interface{} 2785 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2786 var snapshot bytes.Buffer 2787 io.Copy(&snapshot, ringBuffer) 2788 err = &smithy.DeserializationError{ 2789 Err: fmt.Errorf("failed to decode response body, %w", err), 2790 Snapshot: snapshot.Bytes(), 2791 } 2792 return out, metadata, err 2793 } 2794 2795 err = awsAwsjson11_deserializeOpDocumentPutApprovalResultOutput(&output, shape) 2796 if err != nil { 2797 var snapshot bytes.Buffer 2798 io.Copy(&snapshot, ringBuffer) 2799 err = &smithy.DeserializationError{ 2800 Err: fmt.Errorf("failed to decode response body, %w", err), 2801 Snapshot: snapshot.Bytes(), 2802 } 2803 return out, metadata, err 2804 } 2805 2806 return out, metadata, err 2807} 2808 2809func awsAwsjson11_deserializeOpErrorPutApprovalResult(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2810 var errorBuffer bytes.Buffer 2811 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2812 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2813 } 2814 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2815 2816 errorCode := "UnknownError" 2817 errorMessage := errorCode 2818 2819 code := response.Header.Get("X-Amzn-ErrorType") 2820 if len(code) != 0 { 2821 errorCode = restjson.SanitizeErrorCode(code) 2822 } 2823 2824 var buff [1024]byte 2825 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2826 2827 body := io.TeeReader(errorBody, ringBuffer) 2828 decoder := json.NewDecoder(body) 2829 decoder.UseNumber() 2830 code, message, err := restjson.GetErrorInfo(decoder) 2831 if err != nil { 2832 var snapshot bytes.Buffer 2833 io.Copy(&snapshot, ringBuffer) 2834 err = &smithy.DeserializationError{ 2835 Err: fmt.Errorf("failed to decode response body, %w", err), 2836 Snapshot: snapshot.Bytes(), 2837 } 2838 return err 2839 } 2840 2841 errorBody.Seek(0, io.SeekStart) 2842 if len(code) != 0 { 2843 errorCode = restjson.SanitizeErrorCode(code) 2844 } 2845 if len(message) != 0 { 2846 errorMessage = message 2847 } 2848 2849 switch { 2850 case strings.EqualFold("ActionNotFoundException", errorCode): 2851 return awsAwsjson11_deserializeErrorActionNotFoundException(response, errorBody) 2852 2853 case strings.EqualFold("ApprovalAlreadyCompletedException", errorCode): 2854 return awsAwsjson11_deserializeErrorApprovalAlreadyCompletedException(response, errorBody) 2855 2856 case strings.EqualFold("InvalidApprovalTokenException", errorCode): 2857 return awsAwsjson11_deserializeErrorInvalidApprovalTokenException(response, errorBody) 2858 2859 case strings.EqualFold("PipelineNotFoundException", errorCode): 2860 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 2861 2862 case strings.EqualFold("StageNotFoundException", errorCode): 2863 return awsAwsjson11_deserializeErrorStageNotFoundException(response, errorBody) 2864 2865 case strings.EqualFold("ValidationException", errorCode): 2866 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2867 2868 default: 2869 genericError := &smithy.GenericAPIError{ 2870 Code: errorCode, 2871 Message: errorMessage, 2872 } 2873 return genericError 2874 2875 } 2876} 2877 2878type awsAwsjson11_deserializeOpPutJobFailureResult struct { 2879} 2880 2881func (*awsAwsjson11_deserializeOpPutJobFailureResult) ID() string { 2882 return "OperationDeserializer" 2883} 2884 2885func (m *awsAwsjson11_deserializeOpPutJobFailureResult) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2886 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2887) { 2888 out, metadata, err = next.HandleDeserialize(ctx, in) 2889 if err != nil { 2890 return out, metadata, err 2891 } 2892 2893 response, ok := out.RawResponse.(*smithyhttp.Response) 2894 if !ok { 2895 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2896 } 2897 2898 if response.StatusCode < 200 || response.StatusCode >= 300 { 2899 return out, metadata, awsAwsjson11_deserializeOpErrorPutJobFailureResult(response, &metadata) 2900 } 2901 output := &PutJobFailureResultOutput{} 2902 out.Result = output 2903 2904 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2905 return out, metadata, &smithy.DeserializationError{ 2906 Err: fmt.Errorf("failed to discard response body, %w", err), 2907 } 2908 } 2909 2910 return out, metadata, err 2911} 2912 2913func awsAwsjson11_deserializeOpErrorPutJobFailureResult(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2914 var errorBuffer bytes.Buffer 2915 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2916 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2917 } 2918 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2919 2920 errorCode := "UnknownError" 2921 errorMessage := errorCode 2922 2923 code := response.Header.Get("X-Amzn-ErrorType") 2924 if len(code) != 0 { 2925 errorCode = restjson.SanitizeErrorCode(code) 2926 } 2927 2928 var buff [1024]byte 2929 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2930 2931 body := io.TeeReader(errorBody, ringBuffer) 2932 decoder := json.NewDecoder(body) 2933 decoder.UseNumber() 2934 code, message, err := restjson.GetErrorInfo(decoder) 2935 if err != nil { 2936 var snapshot bytes.Buffer 2937 io.Copy(&snapshot, ringBuffer) 2938 err = &smithy.DeserializationError{ 2939 Err: fmt.Errorf("failed to decode response body, %w", err), 2940 Snapshot: snapshot.Bytes(), 2941 } 2942 return err 2943 } 2944 2945 errorBody.Seek(0, io.SeekStart) 2946 if len(code) != 0 { 2947 errorCode = restjson.SanitizeErrorCode(code) 2948 } 2949 if len(message) != 0 { 2950 errorMessage = message 2951 } 2952 2953 switch { 2954 case strings.EqualFold("InvalidJobStateException", errorCode): 2955 return awsAwsjson11_deserializeErrorInvalidJobStateException(response, errorBody) 2956 2957 case strings.EqualFold("JobNotFoundException", errorCode): 2958 return awsAwsjson11_deserializeErrorJobNotFoundException(response, errorBody) 2959 2960 case strings.EqualFold("ValidationException", errorCode): 2961 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2962 2963 default: 2964 genericError := &smithy.GenericAPIError{ 2965 Code: errorCode, 2966 Message: errorMessage, 2967 } 2968 return genericError 2969 2970 } 2971} 2972 2973type awsAwsjson11_deserializeOpPutJobSuccessResult struct { 2974} 2975 2976func (*awsAwsjson11_deserializeOpPutJobSuccessResult) ID() string { 2977 return "OperationDeserializer" 2978} 2979 2980func (m *awsAwsjson11_deserializeOpPutJobSuccessResult) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2981 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2982) { 2983 out, metadata, err = next.HandleDeserialize(ctx, in) 2984 if err != nil { 2985 return out, metadata, err 2986 } 2987 2988 response, ok := out.RawResponse.(*smithyhttp.Response) 2989 if !ok { 2990 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2991 } 2992 2993 if response.StatusCode < 200 || response.StatusCode >= 300 { 2994 return out, metadata, awsAwsjson11_deserializeOpErrorPutJobSuccessResult(response, &metadata) 2995 } 2996 output := &PutJobSuccessResultOutput{} 2997 out.Result = output 2998 2999 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3000 return out, metadata, &smithy.DeserializationError{ 3001 Err: fmt.Errorf("failed to discard response body, %w", err), 3002 } 3003 } 3004 3005 return out, metadata, err 3006} 3007 3008func awsAwsjson11_deserializeOpErrorPutJobSuccessResult(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3009 var errorBuffer bytes.Buffer 3010 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3011 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3012 } 3013 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3014 3015 errorCode := "UnknownError" 3016 errorMessage := errorCode 3017 3018 code := response.Header.Get("X-Amzn-ErrorType") 3019 if len(code) != 0 { 3020 errorCode = restjson.SanitizeErrorCode(code) 3021 } 3022 3023 var buff [1024]byte 3024 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3025 3026 body := io.TeeReader(errorBody, ringBuffer) 3027 decoder := json.NewDecoder(body) 3028 decoder.UseNumber() 3029 code, message, err := restjson.GetErrorInfo(decoder) 3030 if err != nil { 3031 var snapshot bytes.Buffer 3032 io.Copy(&snapshot, ringBuffer) 3033 err = &smithy.DeserializationError{ 3034 Err: fmt.Errorf("failed to decode response body, %w", err), 3035 Snapshot: snapshot.Bytes(), 3036 } 3037 return err 3038 } 3039 3040 errorBody.Seek(0, io.SeekStart) 3041 if len(code) != 0 { 3042 errorCode = restjson.SanitizeErrorCode(code) 3043 } 3044 if len(message) != 0 { 3045 errorMessage = message 3046 } 3047 3048 switch { 3049 case strings.EqualFold("InvalidJobStateException", errorCode): 3050 return awsAwsjson11_deserializeErrorInvalidJobStateException(response, errorBody) 3051 3052 case strings.EqualFold("JobNotFoundException", errorCode): 3053 return awsAwsjson11_deserializeErrorJobNotFoundException(response, errorBody) 3054 3055 case strings.EqualFold("OutputVariablesSizeExceededException", errorCode): 3056 return awsAwsjson11_deserializeErrorOutputVariablesSizeExceededException(response, errorBody) 3057 3058 case strings.EqualFold("ValidationException", errorCode): 3059 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3060 3061 default: 3062 genericError := &smithy.GenericAPIError{ 3063 Code: errorCode, 3064 Message: errorMessage, 3065 } 3066 return genericError 3067 3068 } 3069} 3070 3071type awsAwsjson11_deserializeOpPutThirdPartyJobFailureResult struct { 3072} 3073 3074func (*awsAwsjson11_deserializeOpPutThirdPartyJobFailureResult) ID() string { 3075 return "OperationDeserializer" 3076} 3077 3078func (m *awsAwsjson11_deserializeOpPutThirdPartyJobFailureResult) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3079 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3080) { 3081 out, metadata, err = next.HandleDeserialize(ctx, in) 3082 if err != nil { 3083 return out, metadata, err 3084 } 3085 3086 response, ok := out.RawResponse.(*smithyhttp.Response) 3087 if !ok { 3088 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3089 } 3090 3091 if response.StatusCode < 200 || response.StatusCode >= 300 { 3092 return out, metadata, awsAwsjson11_deserializeOpErrorPutThirdPartyJobFailureResult(response, &metadata) 3093 } 3094 output := &PutThirdPartyJobFailureResultOutput{} 3095 out.Result = output 3096 3097 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3098 return out, metadata, &smithy.DeserializationError{ 3099 Err: fmt.Errorf("failed to discard response body, %w", err), 3100 } 3101 } 3102 3103 return out, metadata, err 3104} 3105 3106func awsAwsjson11_deserializeOpErrorPutThirdPartyJobFailureResult(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3107 var errorBuffer bytes.Buffer 3108 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3109 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3110 } 3111 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3112 3113 errorCode := "UnknownError" 3114 errorMessage := errorCode 3115 3116 code := response.Header.Get("X-Amzn-ErrorType") 3117 if len(code) != 0 { 3118 errorCode = restjson.SanitizeErrorCode(code) 3119 } 3120 3121 var buff [1024]byte 3122 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3123 3124 body := io.TeeReader(errorBody, ringBuffer) 3125 decoder := json.NewDecoder(body) 3126 decoder.UseNumber() 3127 code, message, err := restjson.GetErrorInfo(decoder) 3128 if err != nil { 3129 var snapshot bytes.Buffer 3130 io.Copy(&snapshot, ringBuffer) 3131 err = &smithy.DeserializationError{ 3132 Err: fmt.Errorf("failed to decode response body, %w", err), 3133 Snapshot: snapshot.Bytes(), 3134 } 3135 return err 3136 } 3137 3138 errorBody.Seek(0, io.SeekStart) 3139 if len(code) != 0 { 3140 errorCode = restjson.SanitizeErrorCode(code) 3141 } 3142 if len(message) != 0 { 3143 errorMessage = message 3144 } 3145 3146 switch { 3147 case strings.EqualFold("InvalidClientTokenException", errorCode): 3148 return awsAwsjson11_deserializeErrorInvalidClientTokenException(response, errorBody) 3149 3150 case strings.EqualFold("InvalidJobStateException", errorCode): 3151 return awsAwsjson11_deserializeErrorInvalidJobStateException(response, errorBody) 3152 3153 case strings.EqualFold("JobNotFoundException", errorCode): 3154 return awsAwsjson11_deserializeErrorJobNotFoundException(response, errorBody) 3155 3156 case strings.EqualFold("ValidationException", errorCode): 3157 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3158 3159 default: 3160 genericError := &smithy.GenericAPIError{ 3161 Code: errorCode, 3162 Message: errorMessage, 3163 } 3164 return genericError 3165 3166 } 3167} 3168 3169type awsAwsjson11_deserializeOpPutThirdPartyJobSuccessResult struct { 3170} 3171 3172func (*awsAwsjson11_deserializeOpPutThirdPartyJobSuccessResult) ID() string { 3173 return "OperationDeserializer" 3174} 3175 3176func (m *awsAwsjson11_deserializeOpPutThirdPartyJobSuccessResult) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3177 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3178) { 3179 out, metadata, err = next.HandleDeserialize(ctx, in) 3180 if err != nil { 3181 return out, metadata, err 3182 } 3183 3184 response, ok := out.RawResponse.(*smithyhttp.Response) 3185 if !ok { 3186 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3187 } 3188 3189 if response.StatusCode < 200 || response.StatusCode >= 300 { 3190 return out, metadata, awsAwsjson11_deserializeOpErrorPutThirdPartyJobSuccessResult(response, &metadata) 3191 } 3192 output := &PutThirdPartyJobSuccessResultOutput{} 3193 out.Result = output 3194 3195 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3196 return out, metadata, &smithy.DeserializationError{ 3197 Err: fmt.Errorf("failed to discard response body, %w", err), 3198 } 3199 } 3200 3201 return out, metadata, err 3202} 3203 3204func awsAwsjson11_deserializeOpErrorPutThirdPartyJobSuccessResult(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3205 var errorBuffer bytes.Buffer 3206 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3207 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3208 } 3209 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3210 3211 errorCode := "UnknownError" 3212 errorMessage := errorCode 3213 3214 code := response.Header.Get("X-Amzn-ErrorType") 3215 if len(code) != 0 { 3216 errorCode = restjson.SanitizeErrorCode(code) 3217 } 3218 3219 var buff [1024]byte 3220 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3221 3222 body := io.TeeReader(errorBody, ringBuffer) 3223 decoder := json.NewDecoder(body) 3224 decoder.UseNumber() 3225 code, message, err := restjson.GetErrorInfo(decoder) 3226 if err != nil { 3227 var snapshot bytes.Buffer 3228 io.Copy(&snapshot, ringBuffer) 3229 err = &smithy.DeserializationError{ 3230 Err: fmt.Errorf("failed to decode response body, %w", err), 3231 Snapshot: snapshot.Bytes(), 3232 } 3233 return err 3234 } 3235 3236 errorBody.Seek(0, io.SeekStart) 3237 if len(code) != 0 { 3238 errorCode = restjson.SanitizeErrorCode(code) 3239 } 3240 if len(message) != 0 { 3241 errorMessage = message 3242 } 3243 3244 switch { 3245 case strings.EqualFold("InvalidClientTokenException", errorCode): 3246 return awsAwsjson11_deserializeErrorInvalidClientTokenException(response, errorBody) 3247 3248 case strings.EqualFold("InvalidJobStateException", errorCode): 3249 return awsAwsjson11_deserializeErrorInvalidJobStateException(response, errorBody) 3250 3251 case strings.EqualFold("JobNotFoundException", errorCode): 3252 return awsAwsjson11_deserializeErrorJobNotFoundException(response, errorBody) 3253 3254 case strings.EqualFold("ValidationException", errorCode): 3255 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3256 3257 default: 3258 genericError := &smithy.GenericAPIError{ 3259 Code: errorCode, 3260 Message: errorMessage, 3261 } 3262 return genericError 3263 3264 } 3265} 3266 3267type awsAwsjson11_deserializeOpPutWebhook struct { 3268} 3269 3270func (*awsAwsjson11_deserializeOpPutWebhook) ID() string { 3271 return "OperationDeserializer" 3272} 3273 3274func (m *awsAwsjson11_deserializeOpPutWebhook) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3275 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3276) { 3277 out, metadata, err = next.HandleDeserialize(ctx, in) 3278 if err != nil { 3279 return out, metadata, err 3280 } 3281 3282 response, ok := out.RawResponse.(*smithyhttp.Response) 3283 if !ok { 3284 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3285 } 3286 3287 if response.StatusCode < 200 || response.StatusCode >= 300 { 3288 return out, metadata, awsAwsjson11_deserializeOpErrorPutWebhook(response, &metadata) 3289 } 3290 output := &PutWebhookOutput{} 3291 out.Result = output 3292 3293 var buff [1024]byte 3294 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3295 3296 body := io.TeeReader(response.Body, ringBuffer) 3297 decoder := json.NewDecoder(body) 3298 decoder.UseNumber() 3299 var shape interface{} 3300 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3301 var snapshot bytes.Buffer 3302 io.Copy(&snapshot, ringBuffer) 3303 err = &smithy.DeserializationError{ 3304 Err: fmt.Errorf("failed to decode response body, %w", err), 3305 Snapshot: snapshot.Bytes(), 3306 } 3307 return out, metadata, err 3308 } 3309 3310 err = awsAwsjson11_deserializeOpDocumentPutWebhookOutput(&output, shape) 3311 if err != nil { 3312 var snapshot bytes.Buffer 3313 io.Copy(&snapshot, ringBuffer) 3314 err = &smithy.DeserializationError{ 3315 Err: fmt.Errorf("failed to decode response body, %w", err), 3316 Snapshot: snapshot.Bytes(), 3317 } 3318 return out, metadata, err 3319 } 3320 3321 return out, metadata, err 3322} 3323 3324func awsAwsjson11_deserializeOpErrorPutWebhook(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3325 var errorBuffer bytes.Buffer 3326 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3327 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3328 } 3329 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3330 3331 errorCode := "UnknownError" 3332 errorMessage := errorCode 3333 3334 code := response.Header.Get("X-Amzn-ErrorType") 3335 if len(code) != 0 { 3336 errorCode = restjson.SanitizeErrorCode(code) 3337 } 3338 3339 var buff [1024]byte 3340 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3341 3342 body := io.TeeReader(errorBody, ringBuffer) 3343 decoder := json.NewDecoder(body) 3344 decoder.UseNumber() 3345 code, message, err := restjson.GetErrorInfo(decoder) 3346 if err != nil { 3347 var snapshot bytes.Buffer 3348 io.Copy(&snapshot, ringBuffer) 3349 err = &smithy.DeserializationError{ 3350 Err: fmt.Errorf("failed to decode response body, %w", err), 3351 Snapshot: snapshot.Bytes(), 3352 } 3353 return err 3354 } 3355 3356 errorBody.Seek(0, io.SeekStart) 3357 if len(code) != 0 { 3358 errorCode = restjson.SanitizeErrorCode(code) 3359 } 3360 if len(message) != 0 { 3361 errorMessage = message 3362 } 3363 3364 switch { 3365 case strings.EqualFold("ConcurrentModificationException", errorCode): 3366 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 3367 3368 case strings.EqualFold("InvalidTagsException", errorCode): 3369 return awsAwsjson11_deserializeErrorInvalidTagsException(response, errorBody) 3370 3371 case strings.EqualFold("InvalidWebhookAuthenticationParametersException", errorCode): 3372 return awsAwsjson11_deserializeErrorInvalidWebhookAuthenticationParametersException(response, errorBody) 3373 3374 case strings.EqualFold("InvalidWebhookFilterPatternException", errorCode): 3375 return awsAwsjson11_deserializeErrorInvalidWebhookFilterPatternException(response, errorBody) 3376 3377 case strings.EqualFold("LimitExceededException", errorCode): 3378 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 3379 3380 case strings.EqualFold("PipelineNotFoundException", errorCode): 3381 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 3382 3383 case strings.EqualFold("TooManyTagsException", errorCode): 3384 return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody) 3385 3386 case strings.EqualFold("ValidationException", errorCode): 3387 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3388 3389 default: 3390 genericError := &smithy.GenericAPIError{ 3391 Code: errorCode, 3392 Message: errorMessage, 3393 } 3394 return genericError 3395 3396 } 3397} 3398 3399type awsAwsjson11_deserializeOpRegisterWebhookWithThirdParty struct { 3400} 3401 3402func (*awsAwsjson11_deserializeOpRegisterWebhookWithThirdParty) ID() string { 3403 return "OperationDeserializer" 3404} 3405 3406func (m *awsAwsjson11_deserializeOpRegisterWebhookWithThirdParty) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3407 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3408) { 3409 out, metadata, err = next.HandleDeserialize(ctx, in) 3410 if err != nil { 3411 return out, metadata, err 3412 } 3413 3414 response, ok := out.RawResponse.(*smithyhttp.Response) 3415 if !ok { 3416 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3417 } 3418 3419 if response.StatusCode < 200 || response.StatusCode >= 300 { 3420 return out, metadata, awsAwsjson11_deserializeOpErrorRegisterWebhookWithThirdParty(response, &metadata) 3421 } 3422 output := &RegisterWebhookWithThirdPartyOutput{} 3423 out.Result = output 3424 3425 var buff [1024]byte 3426 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3427 3428 body := io.TeeReader(response.Body, ringBuffer) 3429 decoder := json.NewDecoder(body) 3430 decoder.UseNumber() 3431 var shape interface{} 3432 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3433 var snapshot bytes.Buffer 3434 io.Copy(&snapshot, ringBuffer) 3435 err = &smithy.DeserializationError{ 3436 Err: fmt.Errorf("failed to decode response body, %w", err), 3437 Snapshot: snapshot.Bytes(), 3438 } 3439 return out, metadata, err 3440 } 3441 3442 err = awsAwsjson11_deserializeOpDocumentRegisterWebhookWithThirdPartyOutput(&output, shape) 3443 if err != nil { 3444 var snapshot bytes.Buffer 3445 io.Copy(&snapshot, ringBuffer) 3446 err = &smithy.DeserializationError{ 3447 Err: fmt.Errorf("failed to decode response body, %w", err), 3448 Snapshot: snapshot.Bytes(), 3449 } 3450 return out, metadata, err 3451 } 3452 3453 return out, metadata, err 3454} 3455 3456func awsAwsjson11_deserializeOpErrorRegisterWebhookWithThirdParty(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3457 var errorBuffer bytes.Buffer 3458 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3459 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3460 } 3461 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3462 3463 errorCode := "UnknownError" 3464 errorMessage := errorCode 3465 3466 code := response.Header.Get("X-Amzn-ErrorType") 3467 if len(code) != 0 { 3468 errorCode = restjson.SanitizeErrorCode(code) 3469 } 3470 3471 var buff [1024]byte 3472 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3473 3474 body := io.TeeReader(errorBody, ringBuffer) 3475 decoder := json.NewDecoder(body) 3476 decoder.UseNumber() 3477 code, message, err := restjson.GetErrorInfo(decoder) 3478 if err != nil { 3479 var snapshot bytes.Buffer 3480 io.Copy(&snapshot, ringBuffer) 3481 err = &smithy.DeserializationError{ 3482 Err: fmt.Errorf("failed to decode response body, %w", err), 3483 Snapshot: snapshot.Bytes(), 3484 } 3485 return err 3486 } 3487 3488 errorBody.Seek(0, io.SeekStart) 3489 if len(code) != 0 { 3490 errorCode = restjson.SanitizeErrorCode(code) 3491 } 3492 if len(message) != 0 { 3493 errorMessage = message 3494 } 3495 3496 switch { 3497 case strings.EqualFold("ValidationException", errorCode): 3498 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3499 3500 case strings.EqualFold("WebhookNotFoundException", errorCode): 3501 return awsAwsjson11_deserializeErrorWebhookNotFoundException(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_deserializeOpRetryStageExecution struct { 3514} 3515 3516func (*awsAwsjson11_deserializeOpRetryStageExecution) ID() string { 3517 return "OperationDeserializer" 3518} 3519 3520func (m *awsAwsjson11_deserializeOpRetryStageExecution) 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_deserializeOpErrorRetryStageExecution(response, &metadata) 3535 } 3536 output := &RetryStageExecutionOutput{} 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_deserializeOpDocumentRetryStageExecutionOutput(&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_deserializeOpErrorRetryStageExecution(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("ConflictException", errorCode): 3612 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 3613 3614 case strings.EqualFold("NotLatestPipelineExecutionException", errorCode): 3615 return awsAwsjson11_deserializeErrorNotLatestPipelineExecutionException(response, errorBody) 3616 3617 case strings.EqualFold("PipelineNotFoundException", errorCode): 3618 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 3619 3620 case strings.EqualFold("StageNotFoundException", errorCode): 3621 return awsAwsjson11_deserializeErrorStageNotFoundException(response, errorBody) 3622 3623 case strings.EqualFold("StageNotRetryableException", errorCode): 3624 return awsAwsjson11_deserializeErrorStageNotRetryableException(response, errorBody) 3625 3626 case strings.EqualFold("ValidationException", errorCode): 3627 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3628 3629 default: 3630 genericError := &smithy.GenericAPIError{ 3631 Code: errorCode, 3632 Message: errorMessage, 3633 } 3634 return genericError 3635 3636 } 3637} 3638 3639type awsAwsjson11_deserializeOpStartPipelineExecution struct { 3640} 3641 3642func (*awsAwsjson11_deserializeOpStartPipelineExecution) ID() string { 3643 return "OperationDeserializer" 3644} 3645 3646func (m *awsAwsjson11_deserializeOpStartPipelineExecution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3647 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3648) { 3649 out, metadata, err = next.HandleDeserialize(ctx, in) 3650 if err != nil { 3651 return out, metadata, err 3652 } 3653 3654 response, ok := out.RawResponse.(*smithyhttp.Response) 3655 if !ok { 3656 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3657 } 3658 3659 if response.StatusCode < 200 || response.StatusCode >= 300 { 3660 return out, metadata, awsAwsjson11_deserializeOpErrorStartPipelineExecution(response, &metadata) 3661 } 3662 output := &StartPipelineExecutionOutput{} 3663 out.Result = output 3664 3665 var buff [1024]byte 3666 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3667 3668 body := io.TeeReader(response.Body, ringBuffer) 3669 decoder := json.NewDecoder(body) 3670 decoder.UseNumber() 3671 var shape interface{} 3672 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3673 var snapshot bytes.Buffer 3674 io.Copy(&snapshot, ringBuffer) 3675 err = &smithy.DeserializationError{ 3676 Err: fmt.Errorf("failed to decode response body, %w", err), 3677 Snapshot: snapshot.Bytes(), 3678 } 3679 return out, metadata, err 3680 } 3681 3682 err = awsAwsjson11_deserializeOpDocumentStartPipelineExecutionOutput(&output, shape) 3683 if err != nil { 3684 var snapshot bytes.Buffer 3685 io.Copy(&snapshot, ringBuffer) 3686 err = &smithy.DeserializationError{ 3687 Err: fmt.Errorf("failed to decode response body, %w", err), 3688 Snapshot: snapshot.Bytes(), 3689 } 3690 return out, metadata, err 3691 } 3692 3693 return out, metadata, err 3694} 3695 3696func awsAwsjson11_deserializeOpErrorStartPipelineExecution(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3697 var errorBuffer bytes.Buffer 3698 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3699 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3700 } 3701 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3702 3703 errorCode := "UnknownError" 3704 errorMessage := errorCode 3705 3706 code := response.Header.Get("X-Amzn-ErrorType") 3707 if len(code) != 0 { 3708 errorCode = restjson.SanitizeErrorCode(code) 3709 } 3710 3711 var buff [1024]byte 3712 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3713 3714 body := io.TeeReader(errorBody, ringBuffer) 3715 decoder := json.NewDecoder(body) 3716 decoder.UseNumber() 3717 code, message, err := restjson.GetErrorInfo(decoder) 3718 if err != nil { 3719 var snapshot bytes.Buffer 3720 io.Copy(&snapshot, ringBuffer) 3721 err = &smithy.DeserializationError{ 3722 Err: fmt.Errorf("failed to decode response body, %w", err), 3723 Snapshot: snapshot.Bytes(), 3724 } 3725 return err 3726 } 3727 3728 errorBody.Seek(0, io.SeekStart) 3729 if len(code) != 0 { 3730 errorCode = restjson.SanitizeErrorCode(code) 3731 } 3732 if len(message) != 0 { 3733 errorMessage = message 3734 } 3735 3736 switch { 3737 case strings.EqualFold("ConflictException", errorCode): 3738 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 3739 3740 case strings.EqualFold("PipelineNotFoundException", errorCode): 3741 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 3742 3743 case strings.EqualFold("ValidationException", errorCode): 3744 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3745 3746 default: 3747 genericError := &smithy.GenericAPIError{ 3748 Code: errorCode, 3749 Message: errorMessage, 3750 } 3751 return genericError 3752 3753 } 3754} 3755 3756type awsAwsjson11_deserializeOpStopPipelineExecution struct { 3757} 3758 3759func (*awsAwsjson11_deserializeOpStopPipelineExecution) ID() string { 3760 return "OperationDeserializer" 3761} 3762 3763func (m *awsAwsjson11_deserializeOpStopPipelineExecution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3764 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3765) { 3766 out, metadata, err = next.HandleDeserialize(ctx, in) 3767 if err != nil { 3768 return out, metadata, err 3769 } 3770 3771 response, ok := out.RawResponse.(*smithyhttp.Response) 3772 if !ok { 3773 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3774 } 3775 3776 if response.StatusCode < 200 || response.StatusCode >= 300 { 3777 return out, metadata, awsAwsjson11_deserializeOpErrorStopPipelineExecution(response, &metadata) 3778 } 3779 output := &StopPipelineExecutionOutput{} 3780 out.Result = output 3781 3782 var buff [1024]byte 3783 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3784 3785 body := io.TeeReader(response.Body, ringBuffer) 3786 decoder := json.NewDecoder(body) 3787 decoder.UseNumber() 3788 var shape interface{} 3789 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3790 var snapshot bytes.Buffer 3791 io.Copy(&snapshot, ringBuffer) 3792 err = &smithy.DeserializationError{ 3793 Err: fmt.Errorf("failed to decode response body, %w", err), 3794 Snapshot: snapshot.Bytes(), 3795 } 3796 return out, metadata, err 3797 } 3798 3799 err = awsAwsjson11_deserializeOpDocumentStopPipelineExecutionOutput(&output, shape) 3800 if err != nil { 3801 var snapshot bytes.Buffer 3802 io.Copy(&snapshot, ringBuffer) 3803 err = &smithy.DeserializationError{ 3804 Err: fmt.Errorf("failed to decode response body, %w", err), 3805 Snapshot: snapshot.Bytes(), 3806 } 3807 return out, metadata, err 3808 } 3809 3810 return out, metadata, err 3811} 3812 3813func awsAwsjson11_deserializeOpErrorStopPipelineExecution(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3814 var errorBuffer bytes.Buffer 3815 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3816 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3817 } 3818 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3819 3820 errorCode := "UnknownError" 3821 errorMessage := errorCode 3822 3823 code := response.Header.Get("X-Amzn-ErrorType") 3824 if len(code) != 0 { 3825 errorCode = restjson.SanitizeErrorCode(code) 3826 } 3827 3828 var buff [1024]byte 3829 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3830 3831 body := io.TeeReader(errorBody, ringBuffer) 3832 decoder := json.NewDecoder(body) 3833 decoder.UseNumber() 3834 code, message, err := restjson.GetErrorInfo(decoder) 3835 if err != nil { 3836 var snapshot bytes.Buffer 3837 io.Copy(&snapshot, ringBuffer) 3838 err = &smithy.DeserializationError{ 3839 Err: fmt.Errorf("failed to decode response body, %w", err), 3840 Snapshot: snapshot.Bytes(), 3841 } 3842 return err 3843 } 3844 3845 errorBody.Seek(0, io.SeekStart) 3846 if len(code) != 0 { 3847 errorCode = restjson.SanitizeErrorCode(code) 3848 } 3849 if len(message) != 0 { 3850 errorMessage = message 3851 } 3852 3853 switch { 3854 case strings.EqualFold("ConflictException", errorCode): 3855 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 3856 3857 case strings.EqualFold("DuplicatedStopRequestException", errorCode): 3858 return awsAwsjson11_deserializeErrorDuplicatedStopRequestException(response, errorBody) 3859 3860 case strings.EqualFold("PipelineExecutionNotStoppableException", errorCode): 3861 return awsAwsjson11_deserializeErrorPipelineExecutionNotStoppableException(response, errorBody) 3862 3863 case strings.EqualFold("PipelineNotFoundException", errorCode): 3864 return awsAwsjson11_deserializeErrorPipelineNotFoundException(response, errorBody) 3865 3866 case strings.EqualFold("ValidationException", errorCode): 3867 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3868 3869 default: 3870 genericError := &smithy.GenericAPIError{ 3871 Code: errorCode, 3872 Message: errorMessage, 3873 } 3874 return genericError 3875 3876 } 3877} 3878 3879type awsAwsjson11_deserializeOpTagResource struct { 3880} 3881 3882func (*awsAwsjson11_deserializeOpTagResource) ID() string { 3883 return "OperationDeserializer" 3884} 3885 3886func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3887 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3888) { 3889 out, metadata, err = next.HandleDeserialize(ctx, in) 3890 if err != nil { 3891 return out, metadata, err 3892 } 3893 3894 response, ok := out.RawResponse.(*smithyhttp.Response) 3895 if !ok { 3896 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3897 } 3898 3899 if response.StatusCode < 200 || response.StatusCode >= 300 { 3900 return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata) 3901 } 3902 output := &TagResourceOutput{} 3903 out.Result = output 3904 3905 var buff [1024]byte 3906 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3907 3908 body := io.TeeReader(response.Body, ringBuffer) 3909 decoder := json.NewDecoder(body) 3910 decoder.UseNumber() 3911 var shape interface{} 3912 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3913 var snapshot bytes.Buffer 3914 io.Copy(&snapshot, ringBuffer) 3915 err = &smithy.DeserializationError{ 3916 Err: fmt.Errorf("failed to decode response body, %w", err), 3917 Snapshot: snapshot.Bytes(), 3918 } 3919 return out, metadata, err 3920 } 3921 3922 err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape) 3923 if err != nil { 3924 var snapshot bytes.Buffer 3925 io.Copy(&snapshot, ringBuffer) 3926 err = &smithy.DeserializationError{ 3927 Err: fmt.Errorf("failed to decode response body, %w", err), 3928 Snapshot: snapshot.Bytes(), 3929 } 3930 return out, metadata, err 3931 } 3932 3933 return out, metadata, err 3934} 3935 3936func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3937 var errorBuffer bytes.Buffer 3938 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3939 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3940 } 3941 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3942 3943 errorCode := "UnknownError" 3944 errorMessage := errorCode 3945 3946 code := response.Header.Get("X-Amzn-ErrorType") 3947 if len(code) != 0 { 3948 errorCode = restjson.SanitizeErrorCode(code) 3949 } 3950 3951 var buff [1024]byte 3952 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3953 3954 body := io.TeeReader(errorBody, ringBuffer) 3955 decoder := json.NewDecoder(body) 3956 decoder.UseNumber() 3957 code, message, err := restjson.GetErrorInfo(decoder) 3958 if err != nil { 3959 var snapshot bytes.Buffer 3960 io.Copy(&snapshot, ringBuffer) 3961 err = &smithy.DeserializationError{ 3962 Err: fmt.Errorf("failed to decode response body, %w", err), 3963 Snapshot: snapshot.Bytes(), 3964 } 3965 return err 3966 } 3967 3968 errorBody.Seek(0, io.SeekStart) 3969 if len(code) != 0 { 3970 errorCode = restjson.SanitizeErrorCode(code) 3971 } 3972 if len(message) != 0 { 3973 errorMessage = message 3974 } 3975 3976 switch { 3977 case strings.EqualFold("ConcurrentModificationException", errorCode): 3978 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 3979 3980 case strings.EqualFold("InvalidArnException", errorCode): 3981 return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) 3982 3983 case strings.EqualFold("InvalidTagsException", errorCode): 3984 return awsAwsjson11_deserializeErrorInvalidTagsException(response, errorBody) 3985 3986 case strings.EqualFold("ResourceNotFoundException", errorCode): 3987 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3988 3989 case strings.EqualFold("TooManyTagsException", errorCode): 3990 return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody) 3991 3992 case strings.EqualFold("ValidationException", errorCode): 3993 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3994 3995 default: 3996 genericError := &smithy.GenericAPIError{ 3997 Code: errorCode, 3998 Message: errorMessage, 3999 } 4000 return genericError 4001 4002 } 4003} 4004 4005type awsAwsjson11_deserializeOpUntagResource struct { 4006} 4007 4008func (*awsAwsjson11_deserializeOpUntagResource) ID() string { 4009 return "OperationDeserializer" 4010} 4011 4012func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4013 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4014) { 4015 out, metadata, err = next.HandleDeserialize(ctx, in) 4016 if err != nil { 4017 return out, metadata, err 4018 } 4019 4020 response, ok := out.RawResponse.(*smithyhttp.Response) 4021 if !ok { 4022 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4023 } 4024 4025 if response.StatusCode < 200 || response.StatusCode >= 300 { 4026 return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata) 4027 } 4028 output := &UntagResourceOutput{} 4029 out.Result = output 4030 4031 var buff [1024]byte 4032 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4033 4034 body := io.TeeReader(response.Body, ringBuffer) 4035 decoder := json.NewDecoder(body) 4036 decoder.UseNumber() 4037 var shape interface{} 4038 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4039 var snapshot bytes.Buffer 4040 io.Copy(&snapshot, ringBuffer) 4041 err = &smithy.DeserializationError{ 4042 Err: fmt.Errorf("failed to decode response body, %w", err), 4043 Snapshot: snapshot.Bytes(), 4044 } 4045 return out, metadata, err 4046 } 4047 4048 err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape) 4049 if err != nil { 4050 var snapshot bytes.Buffer 4051 io.Copy(&snapshot, ringBuffer) 4052 err = &smithy.DeserializationError{ 4053 Err: fmt.Errorf("failed to decode response body, %w", err), 4054 Snapshot: snapshot.Bytes(), 4055 } 4056 return out, metadata, err 4057 } 4058 4059 return out, metadata, err 4060} 4061 4062func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4063 var errorBuffer bytes.Buffer 4064 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4065 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4066 } 4067 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4068 4069 errorCode := "UnknownError" 4070 errorMessage := errorCode 4071 4072 code := response.Header.Get("X-Amzn-ErrorType") 4073 if len(code) != 0 { 4074 errorCode = restjson.SanitizeErrorCode(code) 4075 } 4076 4077 var buff [1024]byte 4078 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4079 4080 body := io.TeeReader(errorBody, ringBuffer) 4081 decoder := json.NewDecoder(body) 4082 decoder.UseNumber() 4083 code, message, err := restjson.GetErrorInfo(decoder) 4084 if err != nil { 4085 var snapshot bytes.Buffer 4086 io.Copy(&snapshot, ringBuffer) 4087 err = &smithy.DeserializationError{ 4088 Err: fmt.Errorf("failed to decode response body, %w", err), 4089 Snapshot: snapshot.Bytes(), 4090 } 4091 return err 4092 } 4093 4094 errorBody.Seek(0, io.SeekStart) 4095 if len(code) != 0 { 4096 errorCode = restjson.SanitizeErrorCode(code) 4097 } 4098 if len(message) != 0 { 4099 errorMessage = message 4100 } 4101 4102 switch { 4103 case strings.EqualFold("ConcurrentModificationException", errorCode): 4104 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 4105 4106 case strings.EqualFold("InvalidArnException", errorCode): 4107 return awsAwsjson11_deserializeErrorInvalidArnException(response, errorBody) 4108 4109 case strings.EqualFold("InvalidTagsException", errorCode): 4110 return awsAwsjson11_deserializeErrorInvalidTagsException(response, errorBody) 4111 4112 case strings.EqualFold("ResourceNotFoundException", errorCode): 4113 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4114 4115 case strings.EqualFold("ValidationException", errorCode): 4116 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 4117 4118 default: 4119 genericError := &smithy.GenericAPIError{ 4120 Code: errorCode, 4121 Message: errorMessage, 4122 } 4123 return genericError 4124 4125 } 4126} 4127 4128type awsAwsjson11_deserializeOpUpdatePipeline struct { 4129} 4130 4131func (*awsAwsjson11_deserializeOpUpdatePipeline) ID() string { 4132 return "OperationDeserializer" 4133} 4134 4135func (m *awsAwsjson11_deserializeOpUpdatePipeline) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4136 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4137) { 4138 out, metadata, err = next.HandleDeserialize(ctx, in) 4139 if err != nil { 4140 return out, metadata, err 4141 } 4142 4143 response, ok := out.RawResponse.(*smithyhttp.Response) 4144 if !ok { 4145 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4146 } 4147 4148 if response.StatusCode < 200 || response.StatusCode >= 300 { 4149 return out, metadata, awsAwsjson11_deserializeOpErrorUpdatePipeline(response, &metadata) 4150 } 4151 output := &UpdatePipelineOutput{} 4152 out.Result = output 4153 4154 var buff [1024]byte 4155 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4156 4157 body := io.TeeReader(response.Body, ringBuffer) 4158 decoder := json.NewDecoder(body) 4159 decoder.UseNumber() 4160 var shape interface{} 4161 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4162 var snapshot bytes.Buffer 4163 io.Copy(&snapshot, ringBuffer) 4164 err = &smithy.DeserializationError{ 4165 Err: fmt.Errorf("failed to decode response body, %w", err), 4166 Snapshot: snapshot.Bytes(), 4167 } 4168 return out, metadata, err 4169 } 4170 4171 err = awsAwsjson11_deserializeOpDocumentUpdatePipelineOutput(&output, shape) 4172 if err != nil { 4173 var snapshot bytes.Buffer 4174 io.Copy(&snapshot, ringBuffer) 4175 err = &smithy.DeserializationError{ 4176 Err: fmt.Errorf("failed to decode response body, %w", err), 4177 Snapshot: snapshot.Bytes(), 4178 } 4179 return out, metadata, err 4180 } 4181 4182 return out, metadata, err 4183} 4184 4185func awsAwsjson11_deserializeOpErrorUpdatePipeline(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4186 var errorBuffer bytes.Buffer 4187 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4188 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4189 } 4190 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4191 4192 errorCode := "UnknownError" 4193 errorMessage := errorCode 4194 4195 code := response.Header.Get("X-Amzn-ErrorType") 4196 if len(code) != 0 { 4197 errorCode = restjson.SanitizeErrorCode(code) 4198 } 4199 4200 var buff [1024]byte 4201 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4202 4203 body := io.TeeReader(errorBody, ringBuffer) 4204 decoder := json.NewDecoder(body) 4205 decoder.UseNumber() 4206 code, message, err := restjson.GetErrorInfo(decoder) 4207 if err != nil { 4208 var snapshot bytes.Buffer 4209 io.Copy(&snapshot, ringBuffer) 4210 err = &smithy.DeserializationError{ 4211 Err: fmt.Errorf("failed to decode response body, %w", err), 4212 Snapshot: snapshot.Bytes(), 4213 } 4214 return err 4215 } 4216 4217 errorBody.Seek(0, io.SeekStart) 4218 if len(code) != 0 { 4219 errorCode = restjson.SanitizeErrorCode(code) 4220 } 4221 if len(message) != 0 { 4222 errorMessage = message 4223 } 4224 4225 switch { 4226 case strings.EqualFold("InvalidActionDeclarationException", errorCode): 4227 return awsAwsjson11_deserializeErrorInvalidActionDeclarationException(response, errorBody) 4228 4229 case strings.EqualFold("InvalidBlockerDeclarationException", errorCode): 4230 return awsAwsjson11_deserializeErrorInvalidBlockerDeclarationException(response, errorBody) 4231 4232 case strings.EqualFold("InvalidStageDeclarationException", errorCode): 4233 return awsAwsjson11_deserializeErrorInvalidStageDeclarationException(response, errorBody) 4234 4235 case strings.EqualFold("InvalidStructureException", errorCode): 4236 return awsAwsjson11_deserializeErrorInvalidStructureException(response, errorBody) 4237 4238 case strings.EqualFold("LimitExceededException", errorCode): 4239 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 4240 4241 case strings.EqualFold("ValidationException", errorCode): 4242 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 4243 4244 default: 4245 genericError := &smithy.GenericAPIError{ 4246 Code: errorCode, 4247 Message: errorMessage, 4248 } 4249 return genericError 4250 4251 } 4252} 4253 4254func awsAwsjson11_deserializeErrorActionNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4255 var buff [1024]byte 4256 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4257 4258 body := io.TeeReader(errorBody, ringBuffer) 4259 decoder := json.NewDecoder(body) 4260 decoder.UseNumber() 4261 var shape interface{} 4262 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4263 var snapshot bytes.Buffer 4264 io.Copy(&snapshot, ringBuffer) 4265 err = &smithy.DeserializationError{ 4266 Err: fmt.Errorf("failed to decode response body, %w", err), 4267 Snapshot: snapshot.Bytes(), 4268 } 4269 return err 4270 } 4271 4272 output := &types.ActionNotFoundException{} 4273 err := awsAwsjson11_deserializeDocumentActionNotFoundException(&output, shape) 4274 4275 if err != nil { 4276 var snapshot bytes.Buffer 4277 io.Copy(&snapshot, ringBuffer) 4278 err = &smithy.DeserializationError{ 4279 Err: fmt.Errorf("failed to decode response body, %w", err), 4280 Snapshot: snapshot.Bytes(), 4281 } 4282 return err 4283 } 4284 4285 errorBody.Seek(0, io.SeekStart) 4286 return output 4287} 4288 4289func awsAwsjson11_deserializeErrorActionTypeNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4290 var buff [1024]byte 4291 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4292 4293 body := io.TeeReader(errorBody, ringBuffer) 4294 decoder := json.NewDecoder(body) 4295 decoder.UseNumber() 4296 var shape interface{} 4297 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4298 var snapshot bytes.Buffer 4299 io.Copy(&snapshot, ringBuffer) 4300 err = &smithy.DeserializationError{ 4301 Err: fmt.Errorf("failed to decode response body, %w", err), 4302 Snapshot: snapshot.Bytes(), 4303 } 4304 return err 4305 } 4306 4307 output := &types.ActionTypeNotFoundException{} 4308 err := awsAwsjson11_deserializeDocumentActionTypeNotFoundException(&output, shape) 4309 4310 if err != nil { 4311 var snapshot bytes.Buffer 4312 io.Copy(&snapshot, ringBuffer) 4313 err = &smithy.DeserializationError{ 4314 Err: fmt.Errorf("failed to decode response body, %w", err), 4315 Snapshot: snapshot.Bytes(), 4316 } 4317 return err 4318 } 4319 4320 errorBody.Seek(0, io.SeekStart) 4321 return output 4322} 4323 4324func awsAwsjson11_deserializeErrorApprovalAlreadyCompletedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4325 var buff [1024]byte 4326 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4327 4328 body := io.TeeReader(errorBody, ringBuffer) 4329 decoder := json.NewDecoder(body) 4330 decoder.UseNumber() 4331 var shape interface{} 4332 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4333 var snapshot bytes.Buffer 4334 io.Copy(&snapshot, ringBuffer) 4335 err = &smithy.DeserializationError{ 4336 Err: fmt.Errorf("failed to decode response body, %w", err), 4337 Snapshot: snapshot.Bytes(), 4338 } 4339 return err 4340 } 4341 4342 output := &types.ApprovalAlreadyCompletedException{} 4343 err := awsAwsjson11_deserializeDocumentApprovalAlreadyCompletedException(&output, shape) 4344 4345 if err != nil { 4346 var snapshot bytes.Buffer 4347 io.Copy(&snapshot, ringBuffer) 4348 err = &smithy.DeserializationError{ 4349 Err: fmt.Errorf("failed to decode response body, %w", err), 4350 Snapshot: snapshot.Bytes(), 4351 } 4352 return err 4353 } 4354 4355 errorBody.Seek(0, io.SeekStart) 4356 return output 4357} 4358 4359func awsAwsjson11_deserializeErrorConcurrentModificationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4360 var buff [1024]byte 4361 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4362 4363 body := io.TeeReader(errorBody, ringBuffer) 4364 decoder := json.NewDecoder(body) 4365 decoder.UseNumber() 4366 var shape interface{} 4367 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4368 var snapshot bytes.Buffer 4369 io.Copy(&snapshot, ringBuffer) 4370 err = &smithy.DeserializationError{ 4371 Err: fmt.Errorf("failed to decode response body, %w", err), 4372 Snapshot: snapshot.Bytes(), 4373 } 4374 return err 4375 } 4376 4377 output := &types.ConcurrentModificationException{} 4378 err := awsAwsjson11_deserializeDocumentConcurrentModificationException(&output, shape) 4379 4380 if err != nil { 4381 var snapshot bytes.Buffer 4382 io.Copy(&snapshot, ringBuffer) 4383 err = &smithy.DeserializationError{ 4384 Err: fmt.Errorf("failed to decode response body, %w", err), 4385 Snapshot: snapshot.Bytes(), 4386 } 4387 return err 4388 } 4389 4390 errorBody.Seek(0, io.SeekStart) 4391 return output 4392} 4393 4394func awsAwsjson11_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4395 var buff [1024]byte 4396 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4397 4398 body := io.TeeReader(errorBody, ringBuffer) 4399 decoder := json.NewDecoder(body) 4400 decoder.UseNumber() 4401 var shape interface{} 4402 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4403 var snapshot bytes.Buffer 4404 io.Copy(&snapshot, ringBuffer) 4405 err = &smithy.DeserializationError{ 4406 Err: fmt.Errorf("failed to decode response body, %w", err), 4407 Snapshot: snapshot.Bytes(), 4408 } 4409 return err 4410 } 4411 4412 output := &types.ConflictException{} 4413 err := awsAwsjson11_deserializeDocumentConflictException(&output, shape) 4414 4415 if err != nil { 4416 var snapshot bytes.Buffer 4417 io.Copy(&snapshot, ringBuffer) 4418 err = &smithy.DeserializationError{ 4419 Err: fmt.Errorf("failed to decode response body, %w", err), 4420 Snapshot: snapshot.Bytes(), 4421 } 4422 return err 4423 } 4424 4425 errorBody.Seek(0, io.SeekStart) 4426 return output 4427} 4428 4429func awsAwsjson11_deserializeErrorDuplicatedStopRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4430 var buff [1024]byte 4431 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4432 4433 body := io.TeeReader(errorBody, ringBuffer) 4434 decoder := json.NewDecoder(body) 4435 decoder.UseNumber() 4436 var shape interface{} 4437 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4438 var snapshot bytes.Buffer 4439 io.Copy(&snapshot, ringBuffer) 4440 err = &smithy.DeserializationError{ 4441 Err: fmt.Errorf("failed to decode response body, %w", err), 4442 Snapshot: snapshot.Bytes(), 4443 } 4444 return err 4445 } 4446 4447 output := &types.DuplicatedStopRequestException{} 4448 err := awsAwsjson11_deserializeDocumentDuplicatedStopRequestException(&output, shape) 4449 4450 if err != nil { 4451 var snapshot bytes.Buffer 4452 io.Copy(&snapshot, ringBuffer) 4453 err = &smithy.DeserializationError{ 4454 Err: fmt.Errorf("failed to decode response body, %w", err), 4455 Snapshot: snapshot.Bytes(), 4456 } 4457 return err 4458 } 4459 4460 errorBody.Seek(0, io.SeekStart) 4461 return output 4462} 4463 4464func awsAwsjson11_deserializeErrorInvalidActionDeclarationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4465 var buff [1024]byte 4466 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4467 4468 body := io.TeeReader(errorBody, ringBuffer) 4469 decoder := json.NewDecoder(body) 4470 decoder.UseNumber() 4471 var shape interface{} 4472 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4473 var snapshot bytes.Buffer 4474 io.Copy(&snapshot, ringBuffer) 4475 err = &smithy.DeserializationError{ 4476 Err: fmt.Errorf("failed to decode response body, %w", err), 4477 Snapshot: snapshot.Bytes(), 4478 } 4479 return err 4480 } 4481 4482 output := &types.InvalidActionDeclarationException{} 4483 err := awsAwsjson11_deserializeDocumentInvalidActionDeclarationException(&output, shape) 4484 4485 if err != nil { 4486 var snapshot bytes.Buffer 4487 io.Copy(&snapshot, ringBuffer) 4488 err = &smithy.DeserializationError{ 4489 Err: fmt.Errorf("failed to decode response body, %w", err), 4490 Snapshot: snapshot.Bytes(), 4491 } 4492 return err 4493 } 4494 4495 errorBody.Seek(0, io.SeekStart) 4496 return output 4497} 4498 4499func awsAwsjson11_deserializeErrorInvalidApprovalTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4500 var buff [1024]byte 4501 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4502 4503 body := io.TeeReader(errorBody, ringBuffer) 4504 decoder := json.NewDecoder(body) 4505 decoder.UseNumber() 4506 var shape interface{} 4507 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4508 var snapshot bytes.Buffer 4509 io.Copy(&snapshot, ringBuffer) 4510 err = &smithy.DeserializationError{ 4511 Err: fmt.Errorf("failed to decode response body, %w", err), 4512 Snapshot: snapshot.Bytes(), 4513 } 4514 return err 4515 } 4516 4517 output := &types.InvalidApprovalTokenException{} 4518 err := awsAwsjson11_deserializeDocumentInvalidApprovalTokenException(&output, shape) 4519 4520 if err != nil { 4521 var snapshot bytes.Buffer 4522 io.Copy(&snapshot, ringBuffer) 4523 err = &smithy.DeserializationError{ 4524 Err: fmt.Errorf("failed to decode response body, %w", err), 4525 Snapshot: snapshot.Bytes(), 4526 } 4527 return err 4528 } 4529 4530 errorBody.Seek(0, io.SeekStart) 4531 return output 4532} 4533 4534func awsAwsjson11_deserializeErrorInvalidArnException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4535 var buff [1024]byte 4536 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4537 4538 body := io.TeeReader(errorBody, ringBuffer) 4539 decoder := json.NewDecoder(body) 4540 decoder.UseNumber() 4541 var shape interface{} 4542 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4543 var snapshot bytes.Buffer 4544 io.Copy(&snapshot, ringBuffer) 4545 err = &smithy.DeserializationError{ 4546 Err: fmt.Errorf("failed to decode response body, %w", err), 4547 Snapshot: snapshot.Bytes(), 4548 } 4549 return err 4550 } 4551 4552 output := &types.InvalidArnException{} 4553 err := awsAwsjson11_deserializeDocumentInvalidArnException(&output, shape) 4554 4555 if err != nil { 4556 var snapshot bytes.Buffer 4557 io.Copy(&snapshot, ringBuffer) 4558 err = &smithy.DeserializationError{ 4559 Err: fmt.Errorf("failed to decode response body, %w", err), 4560 Snapshot: snapshot.Bytes(), 4561 } 4562 return err 4563 } 4564 4565 errorBody.Seek(0, io.SeekStart) 4566 return output 4567} 4568 4569func awsAwsjson11_deserializeErrorInvalidBlockerDeclarationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4570 var buff [1024]byte 4571 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4572 4573 body := io.TeeReader(errorBody, ringBuffer) 4574 decoder := json.NewDecoder(body) 4575 decoder.UseNumber() 4576 var shape interface{} 4577 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4578 var snapshot bytes.Buffer 4579 io.Copy(&snapshot, ringBuffer) 4580 err = &smithy.DeserializationError{ 4581 Err: fmt.Errorf("failed to decode response body, %w", err), 4582 Snapshot: snapshot.Bytes(), 4583 } 4584 return err 4585 } 4586 4587 output := &types.InvalidBlockerDeclarationException{} 4588 err := awsAwsjson11_deserializeDocumentInvalidBlockerDeclarationException(&output, shape) 4589 4590 if err != nil { 4591 var snapshot bytes.Buffer 4592 io.Copy(&snapshot, ringBuffer) 4593 err = &smithy.DeserializationError{ 4594 Err: fmt.Errorf("failed to decode response body, %w", err), 4595 Snapshot: snapshot.Bytes(), 4596 } 4597 return err 4598 } 4599 4600 errorBody.Seek(0, io.SeekStart) 4601 return output 4602} 4603 4604func awsAwsjson11_deserializeErrorInvalidClientTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4605 var buff [1024]byte 4606 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4607 4608 body := io.TeeReader(errorBody, ringBuffer) 4609 decoder := json.NewDecoder(body) 4610 decoder.UseNumber() 4611 var shape interface{} 4612 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4613 var snapshot bytes.Buffer 4614 io.Copy(&snapshot, ringBuffer) 4615 err = &smithy.DeserializationError{ 4616 Err: fmt.Errorf("failed to decode response body, %w", err), 4617 Snapshot: snapshot.Bytes(), 4618 } 4619 return err 4620 } 4621 4622 output := &types.InvalidClientTokenException{} 4623 err := awsAwsjson11_deserializeDocumentInvalidClientTokenException(&output, shape) 4624 4625 if err != nil { 4626 var snapshot bytes.Buffer 4627 io.Copy(&snapshot, ringBuffer) 4628 err = &smithy.DeserializationError{ 4629 Err: fmt.Errorf("failed to decode response body, %w", err), 4630 Snapshot: snapshot.Bytes(), 4631 } 4632 return err 4633 } 4634 4635 errorBody.Seek(0, io.SeekStart) 4636 return output 4637} 4638 4639func awsAwsjson11_deserializeErrorInvalidJobException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4640 var buff [1024]byte 4641 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4642 4643 body := io.TeeReader(errorBody, ringBuffer) 4644 decoder := json.NewDecoder(body) 4645 decoder.UseNumber() 4646 var shape interface{} 4647 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4648 var snapshot bytes.Buffer 4649 io.Copy(&snapshot, ringBuffer) 4650 err = &smithy.DeserializationError{ 4651 Err: fmt.Errorf("failed to decode response body, %w", err), 4652 Snapshot: snapshot.Bytes(), 4653 } 4654 return err 4655 } 4656 4657 output := &types.InvalidJobException{} 4658 err := awsAwsjson11_deserializeDocumentInvalidJobException(&output, shape) 4659 4660 if err != nil { 4661 var snapshot bytes.Buffer 4662 io.Copy(&snapshot, ringBuffer) 4663 err = &smithy.DeserializationError{ 4664 Err: fmt.Errorf("failed to decode response body, %w", err), 4665 Snapshot: snapshot.Bytes(), 4666 } 4667 return err 4668 } 4669 4670 errorBody.Seek(0, io.SeekStart) 4671 return output 4672} 4673 4674func awsAwsjson11_deserializeErrorInvalidJobStateException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4675 var buff [1024]byte 4676 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4677 4678 body := io.TeeReader(errorBody, ringBuffer) 4679 decoder := json.NewDecoder(body) 4680 decoder.UseNumber() 4681 var shape interface{} 4682 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4683 var snapshot bytes.Buffer 4684 io.Copy(&snapshot, ringBuffer) 4685 err = &smithy.DeserializationError{ 4686 Err: fmt.Errorf("failed to decode response body, %w", err), 4687 Snapshot: snapshot.Bytes(), 4688 } 4689 return err 4690 } 4691 4692 output := &types.InvalidJobStateException{} 4693 err := awsAwsjson11_deserializeDocumentInvalidJobStateException(&output, shape) 4694 4695 if err != nil { 4696 var snapshot bytes.Buffer 4697 io.Copy(&snapshot, ringBuffer) 4698 err = &smithy.DeserializationError{ 4699 Err: fmt.Errorf("failed to decode response body, %w", err), 4700 Snapshot: snapshot.Bytes(), 4701 } 4702 return err 4703 } 4704 4705 errorBody.Seek(0, io.SeekStart) 4706 return output 4707} 4708 4709func awsAwsjson11_deserializeErrorInvalidNextTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4710 var buff [1024]byte 4711 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4712 4713 body := io.TeeReader(errorBody, ringBuffer) 4714 decoder := json.NewDecoder(body) 4715 decoder.UseNumber() 4716 var shape interface{} 4717 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4718 var snapshot bytes.Buffer 4719 io.Copy(&snapshot, ringBuffer) 4720 err = &smithy.DeserializationError{ 4721 Err: fmt.Errorf("failed to decode response body, %w", err), 4722 Snapshot: snapshot.Bytes(), 4723 } 4724 return err 4725 } 4726 4727 output := &types.InvalidNextTokenException{} 4728 err := awsAwsjson11_deserializeDocumentInvalidNextTokenException(&output, shape) 4729 4730 if err != nil { 4731 var snapshot bytes.Buffer 4732 io.Copy(&snapshot, ringBuffer) 4733 err = &smithy.DeserializationError{ 4734 Err: fmt.Errorf("failed to decode response body, %w", err), 4735 Snapshot: snapshot.Bytes(), 4736 } 4737 return err 4738 } 4739 4740 errorBody.Seek(0, io.SeekStart) 4741 return output 4742} 4743 4744func awsAwsjson11_deserializeErrorInvalidNonceException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4745 var buff [1024]byte 4746 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4747 4748 body := io.TeeReader(errorBody, ringBuffer) 4749 decoder := json.NewDecoder(body) 4750 decoder.UseNumber() 4751 var shape interface{} 4752 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4753 var snapshot bytes.Buffer 4754 io.Copy(&snapshot, ringBuffer) 4755 err = &smithy.DeserializationError{ 4756 Err: fmt.Errorf("failed to decode response body, %w", err), 4757 Snapshot: snapshot.Bytes(), 4758 } 4759 return err 4760 } 4761 4762 output := &types.InvalidNonceException{} 4763 err := awsAwsjson11_deserializeDocumentInvalidNonceException(&output, shape) 4764 4765 if err != nil { 4766 var snapshot bytes.Buffer 4767 io.Copy(&snapshot, ringBuffer) 4768 err = &smithy.DeserializationError{ 4769 Err: fmt.Errorf("failed to decode response body, %w", err), 4770 Snapshot: snapshot.Bytes(), 4771 } 4772 return err 4773 } 4774 4775 errorBody.Seek(0, io.SeekStart) 4776 return output 4777} 4778 4779func awsAwsjson11_deserializeErrorInvalidStageDeclarationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4780 var buff [1024]byte 4781 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4782 4783 body := io.TeeReader(errorBody, ringBuffer) 4784 decoder := json.NewDecoder(body) 4785 decoder.UseNumber() 4786 var shape interface{} 4787 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4788 var snapshot bytes.Buffer 4789 io.Copy(&snapshot, ringBuffer) 4790 err = &smithy.DeserializationError{ 4791 Err: fmt.Errorf("failed to decode response body, %w", err), 4792 Snapshot: snapshot.Bytes(), 4793 } 4794 return err 4795 } 4796 4797 output := &types.InvalidStageDeclarationException{} 4798 err := awsAwsjson11_deserializeDocumentInvalidStageDeclarationException(&output, shape) 4799 4800 if err != nil { 4801 var snapshot bytes.Buffer 4802 io.Copy(&snapshot, ringBuffer) 4803 err = &smithy.DeserializationError{ 4804 Err: fmt.Errorf("failed to decode response body, %w", err), 4805 Snapshot: snapshot.Bytes(), 4806 } 4807 return err 4808 } 4809 4810 errorBody.Seek(0, io.SeekStart) 4811 return output 4812} 4813 4814func awsAwsjson11_deserializeErrorInvalidStructureException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4815 var buff [1024]byte 4816 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4817 4818 body := io.TeeReader(errorBody, ringBuffer) 4819 decoder := json.NewDecoder(body) 4820 decoder.UseNumber() 4821 var shape interface{} 4822 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4823 var snapshot bytes.Buffer 4824 io.Copy(&snapshot, ringBuffer) 4825 err = &smithy.DeserializationError{ 4826 Err: fmt.Errorf("failed to decode response body, %w", err), 4827 Snapshot: snapshot.Bytes(), 4828 } 4829 return err 4830 } 4831 4832 output := &types.InvalidStructureException{} 4833 err := awsAwsjson11_deserializeDocumentInvalidStructureException(&output, shape) 4834 4835 if err != nil { 4836 var snapshot bytes.Buffer 4837 io.Copy(&snapshot, ringBuffer) 4838 err = &smithy.DeserializationError{ 4839 Err: fmt.Errorf("failed to decode response body, %w", err), 4840 Snapshot: snapshot.Bytes(), 4841 } 4842 return err 4843 } 4844 4845 errorBody.Seek(0, io.SeekStart) 4846 return output 4847} 4848 4849func awsAwsjson11_deserializeErrorInvalidTagsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4850 var buff [1024]byte 4851 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4852 4853 body := io.TeeReader(errorBody, ringBuffer) 4854 decoder := json.NewDecoder(body) 4855 decoder.UseNumber() 4856 var shape interface{} 4857 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4858 var snapshot bytes.Buffer 4859 io.Copy(&snapshot, ringBuffer) 4860 err = &smithy.DeserializationError{ 4861 Err: fmt.Errorf("failed to decode response body, %w", err), 4862 Snapshot: snapshot.Bytes(), 4863 } 4864 return err 4865 } 4866 4867 output := &types.InvalidTagsException{} 4868 err := awsAwsjson11_deserializeDocumentInvalidTagsException(&output, shape) 4869 4870 if err != nil { 4871 var snapshot bytes.Buffer 4872 io.Copy(&snapshot, ringBuffer) 4873 err = &smithy.DeserializationError{ 4874 Err: fmt.Errorf("failed to decode response body, %w", err), 4875 Snapshot: snapshot.Bytes(), 4876 } 4877 return err 4878 } 4879 4880 errorBody.Seek(0, io.SeekStart) 4881 return output 4882} 4883 4884func awsAwsjson11_deserializeErrorInvalidWebhookAuthenticationParametersException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4885 var buff [1024]byte 4886 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4887 4888 body := io.TeeReader(errorBody, ringBuffer) 4889 decoder := json.NewDecoder(body) 4890 decoder.UseNumber() 4891 var shape interface{} 4892 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4893 var snapshot bytes.Buffer 4894 io.Copy(&snapshot, ringBuffer) 4895 err = &smithy.DeserializationError{ 4896 Err: fmt.Errorf("failed to decode response body, %w", err), 4897 Snapshot: snapshot.Bytes(), 4898 } 4899 return err 4900 } 4901 4902 output := &types.InvalidWebhookAuthenticationParametersException{} 4903 err := awsAwsjson11_deserializeDocumentInvalidWebhookAuthenticationParametersException(&output, shape) 4904 4905 if err != nil { 4906 var snapshot bytes.Buffer 4907 io.Copy(&snapshot, ringBuffer) 4908 err = &smithy.DeserializationError{ 4909 Err: fmt.Errorf("failed to decode response body, %w", err), 4910 Snapshot: snapshot.Bytes(), 4911 } 4912 return err 4913 } 4914 4915 errorBody.Seek(0, io.SeekStart) 4916 return output 4917} 4918 4919func awsAwsjson11_deserializeErrorInvalidWebhookFilterPatternException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4920 var buff [1024]byte 4921 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4922 4923 body := io.TeeReader(errorBody, ringBuffer) 4924 decoder := json.NewDecoder(body) 4925 decoder.UseNumber() 4926 var shape interface{} 4927 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4928 var snapshot bytes.Buffer 4929 io.Copy(&snapshot, ringBuffer) 4930 err = &smithy.DeserializationError{ 4931 Err: fmt.Errorf("failed to decode response body, %w", err), 4932 Snapshot: snapshot.Bytes(), 4933 } 4934 return err 4935 } 4936 4937 output := &types.InvalidWebhookFilterPatternException{} 4938 err := awsAwsjson11_deserializeDocumentInvalidWebhookFilterPatternException(&output, shape) 4939 4940 if err != nil { 4941 var snapshot bytes.Buffer 4942 io.Copy(&snapshot, ringBuffer) 4943 err = &smithy.DeserializationError{ 4944 Err: fmt.Errorf("failed to decode response body, %w", err), 4945 Snapshot: snapshot.Bytes(), 4946 } 4947 return err 4948 } 4949 4950 errorBody.Seek(0, io.SeekStart) 4951 return output 4952} 4953 4954func awsAwsjson11_deserializeErrorJobNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4955 var buff [1024]byte 4956 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4957 4958 body := io.TeeReader(errorBody, ringBuffer) 4959 decoder := json.NewDecoder(body) 4960 decoder.UseNumber() 4961 var shape interface{} 4962 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4963 var snapshot bytes.Buffer 4964 io.Copy(&snapshot, ringBuffer) 4965 err = &smithy.DeserializationError{ 4966 Err: fmt.Errorf("failed to decode response body, %w", err), 4967 Snapshot: snapshot.Bytes(), 4968 } 4969 return err 4970 } 4971 4972 output := &types.JobNotFoundException{} 4973 err := awsAwsjson11_deserializeDocumentJobNotFoundException(&output, shape) 4974 4975 if err != nil { 4976 var snapshot bytes.Buffer 4977 io.Copy(&snapshot, ringBuffer) 4978 err = &smithy.DeserializationError{ 4979 Err: fmt.Errorf("failed to decode response body, %w", err), 4980 Snapshot: snapshot.Bytes(), 4981 } 4982 return err 4983 } 4984 4985 errorBody.Seek(0, io.SeekStart) 4986 return output 4987} 4988 4989func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4990 var buff [1024]byte 4991 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4992 4993 body := io.TeeReader(errorBody, ringBuffer) 4994 decoder := json.NewDecoder(body) 4995 decoder.UseNumber() 4996 var shape interface{} 4997 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4998 var snapshot bytes.Buffer 4999 io.Copy(&snapshot, ringBuffer) 5000 err = &smithy.DeserializationError{ 5001 Err: fmt.Errorf("failed to decode response body, %w", err), 5002 Snapshot: snapshot.Bytes(), 5003 } 5004 return err 5005 } 5006 5007 output := &types.LimitExceededException{} 5008 err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape) 5009 5010 if err != nil { 5011 var snapshot bytes.Buffer 5012 io.Copy(&snapshot, ringBuffer) 5013 err = &smithy.DeserializationError{ 5014 Err: fmt.Errorf("failed to decode response body, %w", err), 5015 Snapshot: snapshot.Bytes(), 5016 } 5017 return err 5018 } 5019 5020 errorBody.Seek(0, io.SeekStart) 5021 return output 5022} 5023 5024func awsAwsjson11_deserializeErrorNotLatestPipelineExecutionException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5025 var buff [1024]byte 5026 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5027 5028 body := io.TeeReader(errorBody, ringBuffer) 5029 decoder := json.NewDecoder(body) 5030 decoder.UseNumber() 5031 var shape interface{} 5032 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5033 var snapshot bytes.Buffer 5034 io.Copy(&snapshot, ringBuffer) 5035 err = &smithy.DeserializationError{ 5036 Err: fmt.Errorf("failed to decode response body, %w", err), 5037 Snapshot: snapshot.Bytes(), 5038 } 5039 return err 5040 } 5041 5042 output := &types.NotLatestPipelineExecutionException{} 5043 err := awsAwsjson11_deserializeDocumentNotLatestPipelineExecutionException(&output, shape) 5044 5045 if err != nil { 5046 var snapshot bytes.Buffer 5047 io.Copy(&snapshot, ringBuffer) 5048 err = &smithy.DeserializationError{ 5049 Err: fmt.Errorf("failed to decode response body, %w", err), 5050 Snapshot: snapshot.Bytes(), 5051 } 5052 return err 5053 } 5054 5055 errorBody.Seek(0, io.SeekStart) 5056 return output 5057} 5058 5059func awsAwsjson11_deserializeErrorOutputVariablesSizeExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5060 var buff [1024]byte 5061 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5062 5063 body := io.TeeReader(errorBody, ringBuffer) 5064 decoder := json.NewDecoder(body) 5065 decoder.UseNumber() 5066 var shape interface{} 5067 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5068 var snapshot bytes.Buffer 5069 io.Copy(&snapshot, ringBuffer) 5070 err = &smithy.DeserializationError{ 5071 Err: fmt.Errorf("failed to decode response body, %w", err), 5072 Snapshot: snapshot.Bytes(), 5073 } 5074 return err 5075 } 5076 5077 output := &types.OutputVariablesSizeExceededException{} 5078 err := awsAwsjson11_deserializeDocumentOutputVariablesSizeExceededException(&output, shape) 5079 5080 if err != nil { 5081 var snapshot bytes.Buffer 5082 io.Copy(&snapshot, ringBuffer) 5083 err = &smithy.DeserializationError{ 5084 Err: fmt.Errorf("failed to decode response body, %w", err), 5085 Snapshot: snapshot.Bytes(), 5086 } 5087 return err 5088 } 5089 5090 errorBody.Seek(0, io.SeekStart) 5091 return output 5092} 5093 5094func awsAwsjson11_deserializeErrorPipelineExecutionNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5095 var buff [1024]byte 5096 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5097 5098 body := io.TeeReader(errorBody, ringBuffer) 5099 decoder := json.NewDecoder(body) 5100 decoder.UseNumber() 5101 var shape interface{} 5102 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5103 var snapshot bytes.Buffer 5104 io.Copy(&snapshot, ringBuffer) 5105 err = &smithy.DeserializationError{ 5106 Err: fmt.Errorf("failed to decode response body, %w", err), 5107 Snapshot: snapshot.Bytes(), 5108 } 5109 return err 5110 } 5111 5112 output := &types.PipelineExecutionNotFoundException{} 5113 err := awsAwsjson11_deserializeDocumentPipelineExecutionNotFoundException(&output, shape) 5114 5115 if err != nil { 5116 var snapshot bytes.Buffer 5117 io.Copy(&snapshot, ringBuffer) 5118 err = &smithy.DeserializationError{ 5119 Err: fmt.Errorf("failed to decode response body, %w", err), 5120 Snapshot: snapshot.Bytes(), 5121 } 5122 return err 5123 } 5124 5125 errorBody.Seek(0, io.SeekStart) 5126 return output 5127} 5128 5129func awsAwsjson11_deserializeErrorPipelineExecutionNotStoppableException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5130 var buff [1024]byte 5131 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5132 5133 body := io.TeeReader(errorBody, ringBuffer) 5134 decoder := json.NewDecoder(body) 5135 decoder.UseNumber() 5136 var shape interface{} 5137 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5138 var snapshot bytes.Buffer 5139 io.Copy(&snapshot, ringBuffer) 5140 err = &smithy.DeserializationError{ 5141 Err: fmt.Errorf("failed to decode response body, %w", err), 5142 Snapshot: snapshot.Bytes(), 5143 } 5144 return err 5145 } 5146 5147 output := &types.PipelineExecutionNotStoppableException{} 5148 err := awsAwsjson11_deserializeDocumentPipelineExecutionNotStoppableException(&output, shape) 5149 5150 if err != nil { 5151 var snapshot bytes.Buffer 5152 io.Copy(&snapshot, ringBuffer) 5153 err = &smithy.DeserializationError{ 5154 Err: fmt.Errorf("failed to decode response body, %w", err), 5155 Snapshot: snapshot.Bytes(), 5156 } 5157 return err 5158 } 5159 5160 errorBody.Seek(0, io.SeekStart) 5161 return output 5162} 5163 5164func awsAwsjson11_deserializeErrorPipelineNameInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5165 var buff [1024]byte 5166 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5167 5168 body := io.TeeReader(errorBody, ringBuffer) 5169 decoder := json.NewDecoder(body) 5170 decoder.UseNumber() 5171 var shape interface{} 5172 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5173 var snapshot bytes.Buffer 5174 io.Copy(&snapshot, ringBuffer) 5175 err = &smithy.DeserializationError{ 5176 Err: fmt.Errorf("failed to decode response body, %w", err), 5177 Snapshot: snapshot.Bytes(), 5178 } 5179 return err 5180 } 5181 5182 output := &types.PipelineNameInUseException{} 5183 err := awsAwsjson11_deserializeDocumentPipelineNameInUseException(&output, shape) 5184 5185 if err != nil { 5186 var snapshot bytes.Buffer 5187 io.Copy(&snapshot, ringBuffer) 5188 err = &smithy.DeserializationError{ 5189 Err: fmt.Errorf("failed to decode response body, %w", err), 5190 Snapshot: snapshot.Bytes(), 5191 } 5192 return err 5193 } 5194 5195 errorBody.Seek(0, io.SeekStart) 5196 return output 5197} 5198 5199func awsAwsjson11_deserializeErrorPipelineNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5200 var buff [1024]byte 5201 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5202 5203 body := io.TeeReader(errorBody, ringBuffer) 5204 decoder := json.NewDecoder(body) 5205 decoder.UseNumber() 5206 var shape interface{} 5207 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5208 var snapshot bytes.Buffer 5209 io.Copy(&snapshot, ringBuffer) 5210 err = &smithy.DeserializationError{ 5211 Err: fmt.Errorf("failed to decode response body, %w", err), 5212 Snapshot: snapshot.Bytes(), 5213 } 5214 return err 5215 } 5216 5217 output := &types.PipelineNotFoundException{} 5218 err := awsAwsjson11_deserializeDocumentPipelineNotFoundException(&output, shape) 5219 5220 if err != nil { 5221 var snapshot bytes.Buffer 5222 io.Copy(&snapshot, ringBuffer) 5223 err = &smithy.DeserializationError{ 5224 Err: fmt.Errorf("failed to decode response body, %w", err), 5225 Snapshot: snapshot.Bytes(), 5226 } 5227 return err 5228 } 5229 5230 errorBody.Seek(0, io.SeekStart) 5231 return output 5232} 5233 5234func awsAwsjson11_deserializeErrorPipelineVersionNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5235 var buff [1024]byte 5236 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5237 5238 body := io.TeeReader(errorBody, ringBuffer) 5239 decoder := json.NewDecoder(body) 5240 decoder.UseNumber() 5241 var shape interface{} 5242 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5243 var snapshot bytes.Buffer 5244 io.Copy(&snapshot, ringBuffer) 5245 err = &smithy.DeserializationError{ 5246 Err: fmt.Errorf("failed to decode response body, %w", err), 5247 Snapshot: snapshot.Bytes(), 5248 } 5249 return err 5250 } 5251 5252 output := &types.PipelineVersionNotFoundException{} 5253 err := awsAwsjson11_deserializeDocumentPipelineVersionNotFoundException(&output, shape) 5254 5255 if err != nil { 5256 var snapshot bytes.Buffer 5257 io.Copy(&snapshot, ringBuffer) 5258 err = &smithy.DeserializationError{ 5259 Err: fmt.Errorf("failed to decode response body, %w", err), 5260 Snapshot: snapshot.Bytes(), 5261 } 5262 return err 5263 } 5264 5265 errorBody.Seek(0, io.SeekStart) 5266 return output 5267} 5268 5269func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5270 var buff [1024]byte 5271 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5272 5273 body := io.TeeReader(errorBody, ringBuffer) 5274 decoder := json.NewDecoder(body) 5275 decoder.UseNumber() 5276 var shape interface{} 5277 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5278 var snapshot bytes.Buffer 5279 io.Copy(&snapshot, ringBuffer) 5280 err = &smithy.DeserializationError{ 5281 Err: fmt.Errorf("failed to decode response body, %w", err), 5282 Snapshot: snapshot.Bytes(), 5283 } 5284 return err 5285 } 5286 5287 output := &types.ResourceNotFoundException{} 5288 err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape) 5289 5290 if err != nil { 5291 var snapshot bytes.Buffer 5292 io.Copy(&snapshot, ringBuffer) 5293 err = &smithy.DeserializationError{ 5294 Err: fmt.Errorf("failed to decode response body, %w", err), 5295 Snapshot: snapshot.Bytes(), 5296 } 5297 return err 5298 } 5299 5300 errorBody.Seek(0, io.SeekStart) 5301 return output 5302} 5303 5304func awsAwsjson11_deserializeErrorStageNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5305 var buff [1024]byte 5306 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5307 5308 body := io.TeeReader(errorBody, ringBuffer) 5309 decoder := json.NewDecoder(body) 5310 decoder.UseNumber() 5311 var shape interface{} 5312 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5313 var snapshot bytes.Buffer 5314 io.Copy(&snapshot, ringBuffer) 5315 err = &smithy.DeserializationError{ 5316 Err: fmt.Errorf("failed to decode response body, %w", err), 5317 Snapshot: snapshot.Bytes(), 5318 } 5319 return err 5320 } 5321 5322 output := &types.StageNotFoundException{} 5323 err := awsAwsjson11_deserializeDocumentStageNotFoundException(&output, shape) 5324 5325 if err != nil { 5326 var snapshot bytes.Buffer 5327 io.Copy(&snapshot, ringBuffer) 5328 err = &smithy.DeserializationError{ 5329 Err: fmt.Errorf("failed to decode response body, %w", err), 5330 Snapshot: snapshot.Bytes(), 5331 } 5332 return err 5333 } 5334 5335 errorBody.Seek(0, io.SeekStart) 5336 return output 5337} 5338 5339func awsAwsjson11_deserializeErrorStageNotRetryableException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5340 var buff [1024]byte 5341 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5342 5343 body := io.TeeReader(errorBody, ringBuffer) 5344 decoder := json.NewDecoder(body) 5345 decoder.UseNumber() 5346 var shape interface{} 5347 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5348 var snapshot bytes.Buffer 5349 io.Copy(&snapshot, ringBuffer) 5350 err = &smithy.DeserializationError{ 5351 Err: fmt.Errorf("failed to decode response body, %w", err), 5352 Snapshot: snapshot.Bytes(), 5353 } 5354 return err 5355 } 5356 5357 output := &types.StageNotRetryableException{} 5358 err := awsAwsjson11_deserializeDocumentStageNotRetryableException(&output, shape) 5359 5360 if err != nil { 5361 var snapshot bytes.Buffer 5362 io.Copy(&snapshot, ringBuffer) 5363 err = &smithy.DeserializationError{ 5364 Err: fmt.Errorf("failed to decode response body, %w", err), 5365 Snapshot: snapshot.Bytes(), 5366 } 5367 return err 5368 } 5369 5370 errorBody.Seek(0, io.SeekStart) 5371 return output 5372} 5373 5374func awsAwsjson11_deserializeErrorTooManyTagsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5375 var buff [1024]byte 5376 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5377 5378 body := io.TeeReader(errorBody, ringBuffer) 5379 decoder := json.NewDecoder(body) 5380 decoder.UseNumber() 5381 var shape interface{} 5382 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5383 var snapshot bytes.Buffer 5384 io.Copy(&snapshot, ringBuffer) 5385 err = &smithy.DeserializationError{ 5386 Err: fmt.Errorf("failed to decode response body, %w", err), 5387 Snapshot: snapshot.Bytes(), 5388 } 5389 return err 5390 } 5391 5392 output := &types.TooManyTagsException{} 5393 err := awsAwsjson11_deserializeDocumentTooManyTagsException(&output, shape) 5394 5395 if err != nil { 5396 var snapshot bytes.Buffer 5397 io.Copy(&snapshot, ringBuffer) 5398 err = &smithy.DeserializationError{ 5399 Err: fmt.Errorf("failed to decode response body, %w", err), 5400 Snapshot: snapshot.Bytes(), 5401 } 5402 return err 5403 } 5404 5405 errorBody.Seek(0, io.SeekStart) 5406 return output 5407} 5408 5409func awsAwsjson11_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5410 var buff [1024]byte 5411 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5412 5413 body := io.TeeReader(errorBody, ringBuffer) 5414 decoder := json.NewDecoder(body) 5415 decoder.UseNumber() 5416 var shape interface{} 5417 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5418 var snapshot bytes.Buffer 5419 io.Copy(&snapshot, ringBuffer) 5420 err = &smithy.DeserializationError{ 5421 Err: fmt.Errorf("failed to decode response body, %w", err), 5422 Snapshot: snapshot.Bytes(), 5423 } 5424 return err 5425 } 5426 5427 output := &types.ValidationException{} 5428 err := awsAwsjson11_deserializeDocumentValidationException(&output, shape) 5429 5430 if err != nil { 5431 var snapshot bytes.Buffer 5432 io.Copy(&snapshot, ringBuffer) 5433 err = &smithy.DeserializationError{ 5434 Err: fmt.Errorf("failed to decode response body, %w", err), 5435 Snapshot: snapshot.Bytes(), 5436 } 5437 return err 5438 } 5439 5440 errorBody.Seek(0, io.SeekStart) 5441 return output 5442} 5443 5444func awsAwsjson11_deserializeErrorWebhookNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5445 var buff [1024]byte 5446 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5447 5448 body := io.TeeReader(errorBody, ringBuffer) 5449 decoder := json.NewDecoder(body) 5450 decoder.UseNumber() 5451 var shape interface{} 5452 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5453 var snapshot bytes.Buffer 5454 io.Copy(&snapshot, ringBuffer) 5455 err = &smithy.DeserializationError{ 5456 Err: fmt.Errorf("failed to decode response body, %w", err), 5457 Snapshot: snapshot.Bytes(), 5458 } 5459 return err 5460 } 5461 5462 output := &types.WebhookNotFoundException{} 5463 err := awsAwsjson11_deserializeDocumentWebhookNotFoundException(&output, shape) 5464 5465 if err != nil { 5466 var snapshot bytes.Buffer 5467 io.Copy(&snapshot, ringBuffer) 5468 err = &smithy.DeserializationError{ 5469 Err: fmt.Errorf("failed to decode response body, %w", err), 5470 Snapshot: snapshot.Bytes(), 5471 } 5472 return err 5473 } 5474 5475 errorBody.Seek(0, io.SeekStart) 5476 return output 5477} 5478 5479func awsAwsjson11_deserializeDocumentActionConfiguration(v **types.ActionConfiguration, value interface{}) error { 5480 if v == nil { 5481 return fmt.Errorf("unexpected nil of type %T", v) 5482 } 5483 if value == nil { 5484 return nil 5485 } 5486 5487 shape, ok := value.(map[string]interface{}) 5488 if !ok { 5489 return fmt.Errorf("unexpected JSON type %v", value) 5490 } 5491 5492 var sv *types.ActionConfiguration 5493 if *v == nil { 5494 sv = &types.ActionConfiguration{} 5495 } else { 5496 sv = *v 5497 } 5498 5499 for key, value := range shape { 5500 switch key { 5501 case "configuration": 5502 if err := awsAwsjson11_deserializeDocumentActionConfigurationMap(&sv.Configuration, value); err != nil { 5503 return err 5504 } 5505 5506 default: 5507 _, _ = key, value 5508 5509 } 5510 } 5511 *v = sv 5512 return nil 5513} 5514 5515func awsAwsjson11_deserializeDocumentActionConfigurationMap(v *map[string]string, value interface{}) error { 5516 if v == nil { 5517 return fmt.Errorf("unexpected nil of type %T", v) 5518 } 5519 if value == nil { 5520 return nil 5521 } 5522 5523 shape, ok := value.(map[string]interface{}) 5524 if !ok { 5525 return fmt.Errorf("unexpected JSON type %v", value) 5526 } 5527 5528 var mv map[string]string 5529 if *v == nil { 5530 mv = map[string]string{} 5531 } else { 5532 mv = *v 5533 } 5534 5535 for key, value := range shape { 5536 var parsedVal string 5537 if value != nil { 5538 jtv, ok := value.(string) 5539 if !ok { 5540 return fmt.Errorf("expected ActionConfigurationValue to be of type string, got %T instead", value) 5541 } 5542 parsedVal = jtv 5543 } 5544 mv[key] = parsedVal 5545 5546 } 5547 *v = mv 5548 return nil 5549} 5550 5551func awsAwsjson11_deserializeDocumentActionConfigurationProperty(v **types.ActionConfigurationProperty, value interface{}) error { 5552 if v == nil { 5553 return fmt.Errorf("unexpected nil of type %T", v) 5554 } 5555 if value == nil { 5556 return nil 5557 } 5558 5559 shape, ok := value.(map[string]interface{}) 5560 if !ok { 5561 return fmt.Errorf("unexpected JSON type %v", value) 5562 } 5563 5564 var sv *types.ActionConfigurationProperty 5565 if *v == nil { 5566 sv = &types.ActionConfigurationProperty{} 5567 } else { 5568 sv = *v 5569 } 5570 5571 for key, value := range shape { 5572 switch key { 5573 case "description": 5574 if value != nil { 5575 jtv, ok := value.(string) 5576 if !ok { 5577 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 5578 } 5579 sv.Description = ptr.String(jtv) 5580 } 5581 5582 case "key": 5583 if value != nil { 5584 jtv, ok := value.(bool) 5585 if !ok { 5586 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5587 } 5588 sv.Key = jtv 5589 } 5590 5591 case "name": 5592 if value != nil { 5593 jtv, ok := value.(string) 5594 if !ok { 5595 return fmt.Errorf("expected ActionConfigurationKey to be of type string, got %T instead", value) 5596 } 5597 sv.Name = ptr.String(jtv) 5598 } 5599 5600 case "queryable": 5601 if value != nil { 5602 jtv, ok := value.(bool) 5603 if !ok { 5604 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5605 } 5606 sv.Queryable = jtv 5607 } 5608 5609 case "required": 5610 if value != nil { 5611 jtv, ok := value.(bool) 5612 if !ok { 5613 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5614 } 5615 sv.Required = jtv 5616 } 5617 5618 case "secret": 5619 if value != nil { 5620 jtv, ok := value.(bool) 5621 if !ok { 5622 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5623 } 5624 sv.Secret = jtv 5625 } 5626 5627 case "type": 5628 if value != nil { 5629 jtv, ok := value.(string) 5630 if !ok { 5631 return fmt.Errorf("expected ActionConfigurationPropertyType to be of type string, got %T instead", value) 5632 } 5633 sv.Type = types.ActionConfigurationPropertyType(jtv) 5634 } 5635 5636 default: 5637 _, _ = key, value 5638 5639 } 5640 } 5641 *v = sv 5642 return nil 5643} 5644 5645func awsAwsjson11_deserializeDocumentActionConfigurationPropertyList(v *[]types.ActionConfigurationProperty, value interface{}) error { 5646 if v == nil { 5647 return fmt.Errorf("unexpected nil of type %T", v) 5648 } 5649 if value == nil { 5650 return nil 5651 } 5652 5653 shape, ok := value.([]interface{}) 5654 if !ok { 5655 return fmt.Errorf("unexpected JSON type %v", value) 5656 } 5657 5658 var cv []types.ActionConfigurationProperty 5659 if *v == nil { 5660 cv = []types.ActionConfigurationProperty{} 5661 } else { 5662 cv = *v 5663 } 5664 5665 for _, value := range shape { 5666 var col types.ActionConfigurationProperty 5667 destAddr := &col 5668 if err := awsAwsjson11_deserializeDocumentActionConfigurationProperty(&destAddr, value); err != nil { 5669 return err 5670 } 5671 col = *destAddr 5672 cv = append(cv, col) 5673 5674 } 5675 *v = cv 5676 return nil 5677} 5678 5679func awsAwsjson11_deserializeDocumentActionContext(v **types.ActionContext, value interface{}) error { 5680 if v == nil { 5681 return fmt.Errorf("unexpected nil of type %T", v) 5682 } 5683 if value == nil { 5684 return nil 5685 } 5686 5687 shape, ok := value.(map[string]interface{}) 5688 if !ok { 5689 return fmt.Errorf("unexpected JSON type %v", value) 5690 } 5691 5692 var sv *types.ActionContext 5693 if *v == nil { 5694 sv = &types.ActionContext{} 5695 } else { 5696 sv = *v 5697 } 5698 5699 for key, value := range shape { 5700 switch key { 5701 case "actionExecutionId": 5702 if value != nil { 5703 jtv, ok := value.(string) 5704 if !ok { 5705 return fmt.Errorf("expected ActionExecutionId to be of type string, got %T instead", value) 5706 } 5707 sv.ActionExecutionId = ptr.String(jtv) 5708 } 5709 5710 case "name": 5711 if value != nil { 5712 jtv, ok := value.(string) 5713 if !ok { 5714 return fmt.Errorf("expected ActionName to be of type string, got %T instead", value) 5715 } 5716 sv.Name = ptr.String(jtv) 5717 } 5718 5719 default: 5720 _, _ = key, value 5721 5722 } 5723 } 5724 *v = sv 5725 return nil 5726} 5727 5728func awsAwsjson11_deserializeDocumentActionDeclaration(v **types.ActionDeclaration, value interface{}) error { 5729 if v == nil { 5730 return fmt.Errorf("unexpected nil of type %T", v) 5731 } 5732 if value == nil { 5733 return nil 5734 } 5735 5736 shape, ok := value.(map[string]interface{}) 5737 if !ok { 5738 return fmt.Errorf("unexpected JSON type %v", value) 5739 } 5740 5741 var sv *types.ActionDeclaration 5742 if *v == nil { 5743 sv = &types.ActionDeclaration{} 5744 } else { 5745 sv = *v 5746 } 5747 5748 for key, value := range shape { 5749 switch key { 5750 case "actionTypeId": 5751 if err := awsAwsjson11_deserializeDocumentActionTypeId(&sv.ActionTypeId, value); err != nil { 5752 return err 5753 } 5754 5755 case "configuration": 5756 if err := awsAwsjson11_deserializeDocumentActionConfigurationMap(&sv.Configuration, value); err != nil { 5757 return err 5758 } 5759 5760 case "inputArtifacts": 5761 if err := awsAwsjson11_deserializeDocumentInputArtifactList(&sv.InputArtifacts, value); err != nil { 5762 return err 5763 } 5764 5765 case "name": 5766 if value != nil { 5767 jtv, ok := value.(string) 5768 if !ok { 5769 return fmt.Errorf("expected ActionName to be of type string, got %T instead", value) 5770 } 5771 sv.Name = ptr.String(jtv) 5772 } 5773 5774 case "namespace": 5775 if value != nil { 5776 jtv, ok := value.(string) 5777 if !ok { 5778 return fmt.Errorf("expected ActionNamespace to be of type string, got %T instead", value) 5779 } 5780 sv.Namespace = ptr.String(jtv) 5781 } 5782 5783 case "outputArtifacts": 5784 if err := awsAwsjson11_deserializeDocumentOutputArtifactList(&sv.OutputArtifacts, value); err != nil { 5785 return err 5786 } 5787 5788 case "region": 5789 if value != nil { 5790 jtv, ok := value.(string) 5791 if !ok { 5792 return fmt.Errorf("expected AWSRegionName to be of type string, got %T instead", value) 5793 } 5794 sv.Region = ptr.String(jtv) 5795 } 5796 5797 case "roleArn": 5798 if value != nil { 5799 jtv, ok := value.(string) 5800 if !ok { 5801 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 5802 } 5803 sv.RoleArn = ptr.String(jtv) 5804 } 5805 5806 case "runOrder": 5807 if value != nil { 5808 jtv, ok := value.(json.Number) 5809 if !ok { 5810 return fmt.Errorf("expected ActionRunOrder to be json.Number, got %T instead", value) 5811 } 5812 i64, err := jtv.Int64() 5813 if err != nil { 5814 return err 5815 } 5816 sv.RunOrder = ptr.Int32(int32(i64)) 5817 } 5818 5819 default: 5820 _, _ = key, value 5821 5822 } 5823 } 5824 *v = sv 5825 return nil 5826} 5827 5828func awsAwsjson11_deserializeDocumentActionExecution(v **types.ActionExecution, value interface{}) error { 5829 if v == nil { 5830 return fmt.Errorf("unexpected nil of type %T", v) 5831 } 5832 if value == nil { 5833 return nil 5834 } 5835 5836 shape, ok := value.(map[string]interface{}) 5837 if !ok { 5838 return fmt.Errorf("unexpected JSON type %v", value) 5839 } 5840 5841 var sv *types.ActionExecution 5842 if *v == nil { 5843 sv = &types.ActionExecution{} 5844 } else { 5845 sv = *v 5846 } 5847 5848 for key, value := range shape { 5849 switch key { 5850 case "actionExecutionId": 5851 if value != nil { 5852 jtv, ok := value.(string) 5853 if !ok { 5854 return fmt.Errorf("expected ActionExecutionId to be of type string, got %T instead", value) 5855 } 5856 sv.ActionExecutionId = ptr.String(jtv) 5857 } 5858 5859 case "errorDetails": 5860 if err := awsAwsjson11_deserializeDocumentErrorDetails(&sv.ErrorDetails, value); err != nil { 5861 return err 5862 } 5863 5864 case "externalExecutionId": 5865 if value != nil { 5866 jtv, ok := value.(string) 5867 if !ok { 5868 return fmt.Errorf("expected ExecutionId to be of type string, got %T instead", value) 5869 } 5870 sv.ExternalExecutionId = ptr.String(jtv) 5871 } 5872 5873 case "externalExecutionUrl": 5874 if value != nil { 5875 jtv, ok := value.(string) 5876 if !ok { 5877 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 5878 } 5879 sv.ExternalExecutionUrl = ptr.String(jtv) 5880 } 5881 5882 case "lastStatusChange": 5883 if value != nil { 5884 jtv, ok := value.(json.Number) 5885 if !ok { 5886 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5887 } 5888 f64, err := jtv.Float64() 5889 if err != nil { 5890 return err 5891 } 5892 sv.LastStatusChange = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5893 } 5894 5895 case "lastUpdatedBy": 5896 if value != nil { 5897 jtv, ok := value.(string) 5898 if !ok { 5899 return fmt.Errorf("expected LastUpdatedBy to be of type string, got %T instead", value) 5900 } 5901 sv.LastUpdatedBy = ptr.String(jtv) 5902 } 5903 5904 case "percentComplete": 5905 if value != nil { 5906 jtv, ok := value.(json.Number) 5907 if !ok { 5908 return fmt.Errorf("expected Percentage to be json.Number, got %T instead", value) 5909 } 5910 i64, err := jtv.Int64() 5911 if err != nil { 5912 return err 5913 } 5914 sv.PercentComplete = ptr.Int32(int32(i64)) 5915 } 5916 5917 case "status": 5918 if value != nil { 5919 jtv, ok := value.(string) 5920 if !ok { 5921 return fmt.Errorf("expected ActionExecutionStatus to be of type string, got %T instead", value) 5922 } 5923 sv.Status = types.ActionExecutionStatus(jtv) 5924 } 5925 5926 case "summary": 5927 if value != nil { 5928 jtv, ok := value.(string) 5929 if !ok { 5930 return fmt.Errorf("expected ExecutionSummary to be of type string, got %T instead", value) 5931 } 5932 sv.Summary = ptr.String(jtv) 5933 } 5934 5935 case "token": 5936 if value != nil { 5937 jtv, ok := value.(string) 5938 if !ok { 5939 return fmt.Errorf("expected ActionExecutionToken to be of type string, got %T instead", value) 5940 } 5941 sv.Token = ptr.String(jtv) 5942 } 5943 5944 default: 5945 _, _ = key, value 5946 5947 } 5948 } 5949 *v = sv 5950 return nil 5951} 5952 5953func awsAwsjson11_deserializeDocumentActionExecutionDetail(v **types.ActionExecutionDetail, value interface{}) error { 5954 if v == nil { 5955 return fmt.Errorf("unexpected nil of type %T", v) 5956 } 5957 if value == nil { 5958 return nil 5959 } 5960 5961 shape, ok := value.(map[string]interface{}) 5962 if !ok { 5963 return fmt.Errorf("unexpected JSON type %v", value) 5964 } 5965 5966 var sv *types.ActionExecutionDetail 5967 if *v == nil { 5968 sv = &types.ActionExecutionDetail{} 5969 } else { 5970 sv = *v 5971 } 5972 5973 for key, value := range shape { 5974 switch key { 5975 case "actionExecutionId": 5976 if value != nil { 5977 jtv, ok := value.(string) 5978 if !ok { 5979 return fmt.Errorf("expected ActionExecutionId to be of type string, got %T instead", value) 5980 } 5981 sv.ActionExecutionId = ptr.String(jtv) 5982 } 5983 5984 case "actionName": 5985 if value != nil { 5986 jtv, ok := value.(string) 5987 if !ok { 5988 return fmt.Errorf("expected ActionName to be of type string, got %T instead", value) 5989 } 5990 sv.ActionName = ptr.String(jtv) 5991 } 5992 5993 case "input": 5994 if err := awsAwsjson11_deserializeDocumentActionExecutionInput(&sv.Input, value); err != nil { 5995 return err 5996 } 5997 5998 case "lastUpdateTime": 5999 if value != nil { 6000 jtv, ok := value.(json.Number) 6001 if !ok { 6002 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6003 } 6004 f64, err := jtv.Float64() 6005 if err != nil { 6006 return err 6007 } 6008 sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6009 } 6010 6011 case "output": 6012 if err := awsAwsjson11_deserializeDocumentActionExecutionOutput(&sv.Output, value); err != nil { 6013 return err 6014 } 6015 6016 case "pipelineExecutionId": 6017 if value != nil { 6018 jtv, ok := value.(string) 6019 if !ok { 6020 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 6021 } 6022 sv.PipelineExecutionId = ptr.String(jtv) 6023 } 6024 6025 case "pipelineVersion": 6026 if value != nil { 6027 jtv, ok := value.(json.Number) 6028 if !ok { 6029 return fmt.Errorf("expected PipelineVersion to be json.Number, got %T instead", value) 6030 } 6031 i64, err := jtv.Int64() 6032 if err != nil { 6033 return err 6034 } 6035 sv.PipelineVersion = ptr.Int32(int32(i64)) 6036 } 6037 6038 case "stageName": 6039 if value != nil { 6040 jtv, ok := value.(string) 6041 if !ok { 6042 return fmt.Errorf("expected StageName to be of type string, got %T instead", value) 6043 } 6044 sv.StageName = ptr.String(jtv) 6045 } 6046 6047 case "startTime": 6048 if value != nil { 6049 jtv, ok := value.(json.Number) 6050 if !ok { 6051 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6052 } 6053 f64, err := jtv.Float64() 6054 if err != nil { 6055 return err 6056 } 6057 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6058 } 6059 6060 case "status": 6061 if value != nil { 6062 jtv, ok := value.(string) 6063 if !ok { 6064 return fmt.Errorf("expected ActionExecutionStatus to be of type string, got %T instead", value) 6065 } 6066 sv.Status = types.ActionExecutionStatus(jtv) 6067 } 6068 6069 default: 6070 _, _ = key, value 6071 6072 } 6073 } 6074 *v = sv 6075 return nil 6076} 6077 6078func awsAwsjson11_deserializeDocumentActionExecutionDetailList(v *[]types.ActionExecutionDetail, value interface{}) error { 6079 if v == nil { 6080 return fmt.Errorf("unexpected nil of type %T", v) 6081 } 6082 if value == nil { 6083 return nil 6084 } 6085 6086 shape, ok := value.([]interface{}) 6087 if !ok { 6088 return fmt.Errorf("unexpected JSON type %v", value) 6089 } 6090 6091 var cv []types.ActionExecutionDetail 6092 if *v == nil { 6093 cv = []types.ActionExecutionDetail{} 6094 } else { 6095 cv = *v 6096 } 6097 6098 for _, value := range shape { 6099 var col types.ActionExecutionDetail 6100 destAddr := &col 6101 if err := awsAwsjson11_deserializeDocumentActionExecutionDetail(&destAddr, value); err != nil { 6102 return err 6103 } 6104 col = *destAddr 6105 cv = append(cv, col) 6106 6107 } 6108 *v = cv 6109 return nil 6110} 6111 6112func awsAwsjson11_deserializeDocumentActionExecutionInput(v **types.ActionExecutionInput, value interface{}) error { 6113 if v == nil { 6114 return fmt.Errorf("unexpected nil of type %T", v) 6115 } 6116 if value == nil { 6117 return nil 6118 } 6119 6120 shape, ok := value.(map[string]interface{}) 6121 if !ok { 6122 return fmt.Errorf("unexpected JSON type %v", value) 6123 } 6124 6125 var sv *types.ActionExecutionInput 6126 if *v == nil { 6127 sv = &types.ActionExecutionInput{} 6128 } else { 6129 sv = *v 6130 } 6131 6132 for key, value := range shape { 6133 switch key { 6134 case "actionTypeId": 6135 if err := awsAwsjson11_deserializeDocumentActionTypeId(&sv.ActionTypeId, value); err != nil { 6136 return err 6137 } 6138 6139 case "configuration": 6140 if err := awsAwsjson11_deserializeDocumentActionConfigurationMap(&sv.Configuration, value); err != nil { 6141 return err 6142 } 6143 6144 case "inputArtifacts": 6145 if err := awsAwsjson11_deserializeDocumentArtifactDetailList(&sv.InputArtifacts, value); err != nil { 6146 return err 6147 } 6148 6149 case "namespace": 6150 if value != nil { 6151 jtv, ok := value.(string) 6152 if !ok { 6153 return fmt.Errorf("expected ActionNamespace to be of type string, got %T instead", value) 6154 } 6155 sv.Namespace = ptr.String(jtv) 6156 } 6157 6158 case "region": 6159 if value != nil { 6160 jtv, ok := value.(string) 6161 if !ok { 6162 return fmt.Errorf("expected AWSRegionName to be of type string, got %T instead", value) 6163 } 6164 sv.Region = ptr.String(jtv) 6165 } 6166 6167 case "resolvedConfiguration": 6168 if err := awsAwsjson11_deserializeDocumentResolvedActionConfigurationMap(&sv.ResolvedConfiguration, value); err != nil { 6169 return err 6170 } 6171 6172 case "roleArn": 6173 if value != nil { 6174 jtv, ok := value.(string) 6175 if !ok { 6176 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 6177 } 6178 sv.RoleArn = ptr.String(jtv) 6179 } 6180 6181 default: 6182 _, _ = key, value 6183 6184 } 6185 } 6186 *v = sv 6187 return nil 6188} 6189 6190func awsAwsjson11_deserializeDocumentActionExecutionOutput(v **types.ActionExecutionOutput, value interface{}) error { 6191 if v == nil { 6192 return fmt.Errorf("unexpected nil of type %T", v) 6193 } 6194 if value == nil { 6195 return nil 6196 } 6197 6198 shape, ok := value.(map[string]interface{}) 6199 if !ok { 6200 return fmt.Errorf("unexpected JSON type %v", value) 6201 } 6202 6203 var sv *types.ActionExecutionOutput 6204 if *v == nil { 6205 sv = &types.ActionExecutionOutput{} 6206 } else { 6207 sv = *v 6208 } 6209 6210 for key, value := range shape { 6211 switch key { 6212 case "executionResult": 6213 if err := awsAwsjson11_deserializeDocumentActionExecutionResult(&sv.ExecutionResult, value); err != nil { 6214 return err 6215 } 6216 6217 case "outputArtifacts": 6218 if err := awsAwsjson11_deserializeDocumentArtifactDetailList(&sv.OutputArtifacts, value); err != nil { 6219 return err 6220 } 6221 6222 case "outputVariables": 6223 if err := awsAwsjson11_deserializeDocumentOutputVariablesMap(&sv.OutputVariables, value); err != nil { 6224 return err 6225 } 6226 6227 default: 6228 _, _ = key, value 6229 6230 } 6231 } 6232 *v = sv 6233 return nil 6234} 6235 6236func awsAwsjson11_deserializeDocumentActionExecutionResult(v **types.ActionExecutionResult, value interface{}) error { 6237 if v == nil { 6238 return fmt.Errorf("unexpected nil of type %T", v) 6239 } 6240 if value == nil { 6241 return nil 6242 } 6243 6244 shape, ok := value.(map[string]interface{}) 6245 if !ok { 6246 return fmt.Errorf("unexpected JSON type %v", value) 6247 } 6248 6249 var sv *types.ActionExecutionResult 6250 if *v == nil { 6251 sv = &types.ActionExecutionResult{} 6252 } else { 6253 sv = *v 6254 } 6255 6256 for key, value := range shape { 6257 switch key { 6258 case "externalExecutionId": 6259 if value != nil { 6260 jtv, ok := value.(string) 6261 if !ok { 6262 return fmt.Errorf("expected ExternalExecutionId to be of type string, got %T instead", value) 6263 } 6264 sv.ExternalExecutionId = ptr.String(jtv) 6265 } 6266 6267 case "externalExecutionSummary": 6268 if value != nil { 6269 jtv, ok := value.(string) 6270 if !ok { 6271 return fmt.Errorf("expected ExternalExecutionSummary to be of type string, got %T instead", value) 6272 } 6273 sv.ExternalExecutionSummary = ptr.String(jtv) 6274 } 6275 6276 case "externalExecutionUrl": 6277 if value != nil { 6278 jtv, ok := value.(string) 6279 if !ok { 6280 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 6281 } 6282 sv.ExternalExecutionUrl = ptr.String(jtv) 6283 } 6284 6285 default: 6286 _, _ = key, value 6287 6288 } 6289 } 6290 *v = sv 6291 return nil 6292} 6293 6294func awsAwsjson11_deserializeDocumentActionNotFoundException(v **types.ActionNotFoundException, value interface{}) error { 6295 if v == nil { 6296 return fmt.Errorf("unexpected nil of type %T", v) 6297 } 6298 if value == nil { 6299 return nil 6300 } 6301 6302 shape, ok := value.(map[string]interface{}) 6303 if !ok { 6304 return fmt.Errorf("unexpected JSON type %v", value) 6305 } 6306 6307 var sv *types.ActionNotFoundException 6308 if *v == nil { 6309 sv = &types.ActionNotFoundException{} 6310 } else { 6311 sv = *v 6312 } 6313 6314 for key, value := range shape { 6315 switch key { 6316 case "message": 6317 if value != nil { 6318 jtv, ok := value.(string) 6319 if !ok { 6320 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 6321 } 6322 sv.Message = ptr.String(jtv) 6323 } 6324 6325 default: 6326 _, _ = key, value 6327 6328 } 6329 } 6330 *v = sv 6331 return nil 6332} 6333 6334func awsAwsjson11_deserializeDocumentActionRevision(v **types.ActionRevision, value interface{}) error { 6335 if v == nil { 6336 return fmt.Errorf("unexpected nil of type %T", v) 6337 } 6338 if value == nil { 6339 return nil 6340 } 6341 6342 shape, ok := value.(map[string]interface{}) 6343 if !ok { 6344 return fmt.Errorf("unexpected JSON type %v", value) 6345 } 6346 6347 var sv *types.ActionRevision 6348 if *v == nil { 6349 sv = &types.ActionRevision{} 6350 } else { 6351 sv = *v 6352 } 6353 6354 for key, value := range shape { 6355 switch key { 6356 case "created": 6357 if value != nil { 6358 jtv, ok := value.(json.Number) 6359 if !ok { 6360 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6361 } 6362 f64, err := jtv.Float64() 6363 if err != nil { 6364 return err 6365 } 6366 sv.Created = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6367 } 6368 6369 case "revisionChangeId": 6370 if value != nil { 6371 jtv, ok := value.(string) 6372 if !ok { 6373 return fmt.Errorf("expected RevisionChangeIdentifier to be of type string, got %T instead", value) 6374 } 6375 sv.RevisionChangeId = ptr.String(jtv) 6376 } 6377 6378 case "revisionId": 6379 if value != nil { 6380 jtv, ok := value.(string) 6381 if !ok { 6382 return fmt.Errorf("expected Revision to be of type string, got %T instead", value) 6383 } 6384 sv.RevisionId = ptr.String(jtv) 6385 } 6386 6387 default: 6388 _, _ = key, value 6389 6390 } 6391 } 6392 *v = sv 6393 return nil 6394} 6395 6396func awsAwsjson11_deserializeDocumentActionState(v **types.ActionState, value interface{}) error { 6397 if v == nil { 6398 return fmt.Errorf("unexpected nil of type %T", v) 6399 } 6400 if value == nil { 6401 return nil 6402 } 6403 6404 shape, ok := value.(map[string]interface{}) 6405 if !ok { 6406 return fmt.Errorf("unexpected JSON type %v", value) 6407 } 6408 6409 var sv *types.ActionState 6410 if *v == nil { 6411 sv = &types.ActionState{} 6412 } else { 6413 sv = *v 6414 } 6415 6416 for key, value := range shape { 6417 switch key { 6418 case "actionName": 6419 if value != nil { 6420 jtv, ok := value.(string) 6421 if !ok { 6422 return fmt.Errorf("expected ActionName to be of type string, got %T instead", value) 6423 } 6424 sv.ActionName = ptr.String(jtv) 6425 } 6426 6427 case "currentRevision": 6428 if err := awsAwsjson11_deserializeDocumentActionRevision(&sv.CurrentRevision, value); err != nil { 6429 return err 6430 } 6431 6432 case "entityUrl": 6433 if value != nil { 6434 jtv, ok := value.(string) 6435 if !ok { 6436 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 6437 } 6438 sv.EntityUrl = ptr.String(jtv) 6439 } 6440 6441 case "latestExecution": 6442 if err := awsAwsjson11_deserializeDocumentActionExecution(&sv.LatestExecution, value); err != nil { 6443 return err 6444 } 6445 6446 case "revisionUrl": 6447 if value != nil { 6448 jtv, ok := value.(string) 6449 if !ok { 6450 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 6451 } 6452 sv.RevisionUrl = ptr.String(jtv) 6453 } 6454 6455 default: 6456 _, _ = key, value 6457 6458 } 6459 } 6460 *v = sv 6461 return nil 6462} 6463 6464func awsAwsjson11_deserializeDocumentActionStateList(v *[]types.ActionState, value interface{}) error { 6465 if v == nil { 6466 return fmt.Errorf("unexpected nil of type %T", v) 6467 } 6468 if value == nil { 6469 return nil 6470 } 6471 6472 shape, ok := value.([]interface{}) 6473 if !ok { 6474 return fmt.Errorf("unexpected JSON type %v", value) 6475 } 6476 6477 var cv []types.ActionState 6478 if *v == nil { 6479 cv = []types.ActionState{} 6480 } else { 6481 cv = *v 6482 } 6483 6484 for _, value := range shape { 6485 var col types.ActionState 6486 destAddr := &col 6487 if err := awsAwsjson11_deserializeDocumentActionState(&destAddr, value); err != nil { 6488 return err 6489 } 6490 col = *destAddr 6491 cv = append(cv, col) 6492 6493 } 6494 *v = cv 6495 return nil 6496} 6497 6498func awsAwsjson11_deserializeDocumentActionType(v **types.ActionType, value interface{}) error { 6499 if v == nil { 6500 return fmt.Errorf("unexpected nil of type %T", v) 6501 } 6502 if value == nil { 6503 return nil 6504 } 6505 6506 shape, ok := value.(map[string]interface{}) 6507 if !ok { 6508 return fmt.Errorf("unexpected JSON type %v", value) 6509 } 6510 6511 var sv *types.ActionType 6512 if *v == nil { 6513 sv = &types.ActionType{} 6514 } else { 6515 sv = *v 6516 } 6517 6518 for key, value := range shape { 6519 switch key { 6520 case "actionConfigurationProperties": 6521 if err := awsAwsjson11_deserializeDocumentActionConfigurationPropertyList(&sv.ActionConfigurationProperties, value); err != nil { 6522 return err 6523 } 6524 6525 case "id": 6526 if err := awsAwsjson11_deserializeDocumentActionTypeId(&sv.Id, value); err != nil { 6527 return err 6528 } 6529 6530 case "inputArtifactDetails": 6531 if err := awsAwsjson11_deserializeDocumentArtifactDetails(&sv.InputArtifactDetails, value); err != nil { 6532 return err 6533 } 6534 6535 case "outputArtifactDetails": 6536 if err := awsAwsjson11_deserializeDocumentArtifactDetails(&sv.OutputArtifactDetails, value); err != nil { 6537 return err 6538 } 6539 6540 case "settings": 6541 if err := awsAwsjson11_deserializeDocumentActionTypeSettings(&sv.Settings, value); err != nil { 6542 return err 6543 } 6544 6545 default: 6546 _, _ = key, value 6547 6548 } 6549 } 6550 *v = sv 6551 return nil 6552} 6553 6554func awsAwsjson11_deserializeDocumentActionTypeId(v **types.ActionTypeId, value interface{}) error { 6555 if v == nil { 6556 return fmt.Errorf("unexpected nil of type %T", v) 6557 } 6558 if value == nil { 6559 return nil 6560 } 6561 6562 shape, ok := value.(map[string]interface{}) 6563 if !ok { 6564 return fmt.Errorf("unexpected JSON type %v", value) 6565 } 6566 6567 var sv *types.ActionTypeId 6568 if *v == nil { 6569 sv = &types.ActionTypeId{} 6570 } else { 6571 sv = *v 6572 } 6573 6574 for key, value := range shape { 6575 switch key { 6576 case "category": 6577 if value != nil { 6578 jtv, ok := value.(string) 6579 if !ok { 6580 return fmt.Errorf("expected ActionCategory to be of type string, got %T instead", value) 6581 } 6582 sv.Category = types.ActionCategory(jtv) 6583 } 6584 6585 case "owner": 6586 if value != nil { 6587 jtv, ok := value.(string) 6588 if !ok { 6589 return fmt.Errorf("expected ActionOwner to be of type string, got %T instead", value) 6590 } 6591 sv.Owner = types.ActionOwner(jtv) 6592 } 6593 6594 case "provider": 6595 if value != nil { 6596 jtv, ok := value.(string) 6597 if !ok { 6598 return fmt.Errorf("expected ActionProvider to be of type string, got %T instead", value) 6599 } 6600 sv.Provider = ptr.String(jtv) 6601 } 6602 6603 case "version": 6604 if value != nil { 6605 jtv, ok := value.(string) 6606 if !ok { 6607 return fmt.Errorf("expected Version to be of type string, got %T instead", value) 6608 } 6609 sv.Version = ptr.String(jtv) 6610 } 6611 6612 default: 6613 _, _ = key, value 6614 6615 } 6616 } 6617 *v = sv 6618 return nil 6619} 6620 6621func awsAwsjson11_deserializeDocumentActionTypeList(v *[]types.ActionType, value interface{}) error { 6622 if v == nil { 6623 return fmt.Errorf("unexpected nil of type %T", v) 6624 } 6625 if value == nil { 6626 return nil 6627 } 6628 6629 shape, ok := value.([]interface{}) 6630 if !ok { 6631 return fmt.Errorf("unexpected JSON type %v", value) 6632 } 6633 6634 var cv []types.ActionType 6635 if *v == nil { 6636 cv = []types.ActionType{} 6637 } else { 6638 cv = *v 6639 } 6640 6641 for _, value := range shape { 6642 var col types.ActionType 6643 destAddr := &col 6644 if err := awsAwsjson11_deserializeDocumentActionType(&destAddr, value); err != nil { 6645 return err 6646 } 6647 col = *destAddr 6648 cv = append(cv, col) 6649 6650 } 6651 *v = cv 6652 return nil 6653} 6654 6655func awsAwsjson11_deserializeDocumentActionTypeNotFoundException(v **types.ActionTypeNotFoundException, value interface{}) error { 6656 if v == nil { 6657 return fmt.Errorf("unexpected nil of type %T", v) 6658 } 6659 if value == nil { 6660 return nil 6661 } 6662 6663 shape, ok := value.(map[string]interface{}) 6664 if !ok { 6665 return fmt.Errorf("unexpected JSON type %v", value) 6666 } 6667 6668 var sv *types.ActionTypeNotFoundException 6669 if *v == nil { 6670 sv = &types.ActionTypeNotFoundException{} 6671 } else { 6672 sv = *v 6673 } 6674 6675 for key, value := range shape { 6676 switch key { 6677 case "message": 6678 if value != nil { 6679 jtv, ok := value.(string) 6680 if !ok { 6681 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 6682 } 6683 sv.Message = ptr.String(jtv) 6684 } 6685 6686 default: 6687 _, _ = key, value 6688 6689 } 6690 } 6691 *v = sv 6692 return nil 6693} 6694 6695func awsAwsjson11_deserializeDocumentActionTypeSettings(v **types.ActionTypeSettings, value interface{}) error { 6696 if v == nil { 6697 return fmt.Errorf("unexpected nil of type %T", v) 6698 } 6699 if value == nil { 6700 return nil 6701 } 6702 6703 shape, ok := value.(map[string]interface{}) 6704 if !ok { 6705 return fmt.Errorf("unexpected JSON type %v", value) 6706 } 6707 6708 var sv *types.ActionTypeSettings 6709 if *v == nil { 6710 sv = &types.ActionTypeSettings{} 6711 } else { 6712 sv = *v 6713 } 6714 6715 for key, value := range shape { 6716 switch key { 6717 case "entityUrlTemplate": 6718 if value != nil { 6719 jtv, ok := value.(string) 6720 if !ok { 6721 return fmt.Errorf("expected UrlTemplate to be of type string, got %T instead", value) 6722 } 6723 sv.EntityUrlTemplate = ptr.String(jtv) 6724 } 6725 6726 case "executionUrlTemplate": 6727 if value != nil { 6728 jtv, ok := value.(string) 6729 if !ok { 6730 return fmt.Errorf("expected UrlTemplate to be of type string, got %T instead", value) 6731 } 6732 sv.ExecutionUrlTemplate = ptr.String(jtv) 6733 } 6734 6735 case "revisionUrlTemplate": 6736 if value != nil { 6737 jtv, ok := value.(string) 6738 if !ok { 6739 return fmt.Errorf("expected UrlTemplate to be of type string, got %T instead", value) 6740 } 6741 sv.RevisionUrlTemplate = ptr.String(jtv) 6742 } 6743 6744 case "thirdPartyConfigurationUrl": 6745 if value != nil { 6746 jtv, ok := value.(string) 6747 if !ok { 6748 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 6749 } 6750 sv.ThirdPartyConfigurationUrl = ptr.String(jtv) 6751 } 6752 6753 default: 6754 _, _ = key, value 6755 6756 } 6757 } 6758 *v = sv 6759 return nil 6760} 6761 6762func awsAwsjson11_deserializeDocumentApprovalAlreadyCompletedException(v **types.ApprovalAlreadyCompletedException, value interface{}) error { 6763 if v == nil { 6764 return fmt.Errorf("unexpected nil of type %T", v) 6765 } 6766 if value == nil { 6767 return nil 6768 } 6769 6770 shape, ok := value.(map[string]interface{}) 6771 if !ok { 6772 return fmt.Errorf("unexpected JSON type %v", value) 6773 } 6774 6775 var sv *types.ApprovalAlreadyCompletedException 6776 if *v == nil { 6777 sv = &types.ApprovalAlreadyCompletedException{} 6778 } else { 6779 sv = *v 6780 } 6781 6782 for key, value := range shape { 6783 switch key { 6784 case "message": 6785 if value != nil { 6786 jtv, ok := value.(string) 6787 if !ok { 6788 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 6789 } 6790 sv.Message = ptr.String(jtv) 6791 } 6792 6793 default: 6794 _, _ = key, value 6795 6796 } 6797 } 6798 *v = sv 6799 return nil 6800} 6801 6802func awsAwsjson11_deserializeDocumentArtifact(v **types.Artifact, value interface{}) error { 6803 if v == nil { 6804 return fmt.Errorf("unexpected nil of type %T", v) 6805 } 6806 if value == nil { 6807 return nil 6808 } 6809 6810 shape, ok := value.(map[string]interface{}) 6811 if !ok { 6812 return fmt.Errorf("unexpected JSON type %v", value) 6813 } 6814 6815 var sv *types.Artifact 6816 if *v == nil { 6817 sv = &types.Artifact{} 6818 } else { 6819 sv = *v 6820 } 6821 6822 for key, value := range shape { 6823 switch key { 6824 case "location": 6825 if err := awsAwsjson11_deserializeDocumentArtifactLocation(&sv.Location, value); err != nil { 6826 return err 6827 } 6828 6829 case "name": 6830 if value != nil { 6831 jtv, ok := value.(string) 6832 if !ok { 6833 return fmt.Errorf("expected ArtifactName to be of type string, got %T instead", value) 6834 } 6835 sv.Name = ptr.String(jtv) 6836 } 6837 6838 case "revision": 6839 if value != nil { 6840 jtv, ok := value.(string) 6841 if !ok { 6842 return fmt.Errorf("expected Revision to be of type string, got %T instead", value) 6843 } 6844 sv.Revision = ptr.String(jtv) 6845 } 6846 6847 default: 6848 _, _ = key, value 6849 6850 } 6851 } 6852 *v = sv 6853 return nil 6854} 6855 6856func awsAwsjson11_deserializeDocumentArtifactDetail(v **types.ArtifactDetail, value interface{}) error { 6857 if v == nil { 6858 return fmt.Errorf("unexpected nil of type %T", v) 6859 } 6860 if value == nil { 6861 return nil 6862 } 6863 6864 shape, ok := value.(map[string]interface{}) 6865 if !ok { 6866 return fmt.Errorf("unexpected JSON type %v", value) 6867 } 6868 6869 var sv *types.ArtifactDetail 6870 if *v == nil { 6871 sv = &types.ArtifactDetail{} 6872 } else { 6873 sv = *v 6874 } 6875 6876 for key, value := range shape { 6877 switch key { 6878 case "name": 6879 if value != nil { 6880 jtv, ok := value.(string) 6881 if !ok { 6882 return fmt.Errorf("expected ArtifactName to be of type string, got %T instead", value) 6883 } 6884 sv.Name = ptr.String(jtv) 6885 } 6886 6887 case "s3location": 6888 if err := awsAwsjson11_deserializeDocumentS3Location(&sv.S3location, value); err != nil { 6889 return err 6890 } 6891 6892 default: 6893 _, _ = key, value 6894 6895 } 6896 } 6897 *v = sv 6898 return nil 6899} 6900 6901func awsAwsjson11_deserializeDocumentArtifactDetailList(v *[]types.ArtifactDetail, value interface{}) error { 6902 if v == nil { 6903 return fmt.Errorf("unexpected nil of type %T", v) 6904 } 6905 if value == nil { 6906 return nil 6907 } 6908 6909 shape, ok := value.([]interface{}) 6910 if !ok { 6911 return fmt.Errorf("unexpected JSON type %v", value) 6912 } 6913 6914 var cv []types.ArtifactDetail 6915 if *v == nil { 6916 cv = []types.ArtifactDetail{} 6917 } else { 6918 cv = *v 6919 } 6920 6921 for _, value := range shape { 6922 var col types.ArtifactDetail 6923 destAddr := &col 6924 if err := awsAwsjson11_deserializeDocumentArtifactDetail(&destAddr, value); err != nil { 6925 return err 6926 } 6927 col = *destAddr 6928 cv = append(cv, col) 6929 6930 } 6931 *v = cv 6932 return nil 6933} 6934 6935func awsAwsjson11_deserializeDocumentArtifactDetails(v **types.ArtifactDetails, value interface{}) error { 6936 if v == nil { 6937 return fmt.Errorf("unexpected nil of type %T", v) 6938 } 6939 if value == nil { 6940 return nil 6941 } 6942 6943 shape, ok := value.(map[string]interface{}) 6944 if !ok { 6945 return fmt.Errorf("unexpected JSON type %v", value) 6946 } 6947 6948 var sv *types.ArtifactDetails 6949 if *v == nil { 6950 sv = &types.ArtifactDetails{} 6951 } else { 6952 sv = *v 6953 } 6954 6955 for key, value := range shape { 6956 switch key { 6957 case "maximumCount": 6958 if value != nil { 6959 jtv, ok := value.(json.Number) 6960 if !ok { 6961 return fmt.Errorf("expected MaximumArtifactCount to be json.Number, got %T instead", value) 6962 } 6963 i64, err := jtv.Int64() 6964 if err != nil { 6965 return err 6966 } 6967 sv.MaximumCount = int32(i64) 6968 } 6969 6970 case "minimumCount": 6971 if value != nil { 6972 jtv, ok := value.(json.Number) 6973 if !ok { 6974 return fmt.Errorf("expected MinimumArtifactCount to be json.Number, got %T instead", value) 6975 } 6976 i64, err := jtv.Int64() 6977 if err != nil { 6978 return err 6979 } 6980 sv.MinimumCount = int32(i64) 6981 } 6982 6983 default: 6984 _, _ = key, value 6985 6986 } 6987 } 6988 *v = sv 6989 return nil 6990} 6991 6992func awsAwsjson11_deserializeDocumentArtifactList(v *[]types.Artifact, value interface{}) error { 6993 if v == nil { 6994 return fmt.Errorf("unexpected nil of type %T", v) 6995 } 6996 if value == nil { 6997 return nil 6998 } 6999 7000 shape, ok := value.([]interface{}) 7001 if !ok { 7002 return fmt.Errorf("unexpected JSON type %v", value) 7003 } 7004 7005 var cv []types.Artifact 7006 if *v == nil { 7007 cv = []types.Artifact{} 7008 } else { 7009 cv = *v 7010 } 7011 7012 for _, value := range shape { 7013 var col types.Artifact 7014 destAddr := &col 7015 if err := awsAwsjson11_deserializeDocumentArtifact(&destAddr, value); err != nil { 7016 return err 7017 } 7018 col = *destAddr 7019 cv = append(cv, col) 7020 7021 } 7022 *v = cv 7023 return nil 7024} 7025 7026func awsAwsjson11_deserializeDocumentArtifactLocation(v **types.ArtifactLocation, value interface{}) error { 7027 if v == nil { 7028 return fmt.Errorf("unexpected nil of type %T", v) 7029 } 7030 if value == nil { 7031 return nil 7032 } 7033 7034 shape, ok := value.(map[string]interface{}) 7035 if !ok { 7036 return fmt.Errorf("unexpected JSON type %v", value) 7037 } 7038 7039 var sv *types.ArtifactLocation 7040 if *v == nil { 7041 sv = &types.ArtifactLocation{} 7042 } else { 7043 sv = *v 7044 } 7045 7046 for key, value := range shape { 7047 switch key { 7048 case "s3Location": 7049 if err := awsAwsjson11_deserializeDocumentS3ArtifactLocation(&sv.S3Location, value); err != nil { 7050 return err 7051 } 7052 7053 case "type": 7054 if value != nil { 7055 jtv, ok := value.(string) 7056 if !ok { 7057 return fmt.Errorf("expected ArtifactLocationType to be of type string, got %T instead", value) 7058 } 7059 sv.Type = types.ArtifactLocationType(jtv) 7060 } 7061 7062 default: 7063 _, _ = key, value 7064 7065 } 7066 } 7067 *v = sv 7068 return nil 7069} 7070 7071func awsAwsjson11_deserializeDocumentArtifactRevision(v **types.ArtifactRevision, value interface{}) error { 7072 if v == nil { 7073 return fmt.Errorf("unexpected nil of type %T", v) 7074 } 7075 if value == nil { 7076 return nil 7077 } 7078 7079 shape, ok := value.(map[string]interface{}) 7080 if !ok { 7081 return fmt.Errorf("unexpected JSON type %v", value) 7082 } 7083 7084 var sv *types.ArtifactRevision 7085 if *v == nil { 7086 sv = &types.ArtifactRevision{} 7087 } else { 7088 sv = *v 7089 } 7090 7091 for key, value := range shape { 7092 switch key { 7093 case "created": 7094 if value != nil { 7095 jtv, ok := value.(json.Number) 7096 if !ok { 7097 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7098 } 7099 f64, err := jtv.Float64() 7100 if err != nil { 7101 return err 7102 } 7103 sv.Created = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7104 } 7105 7106 case "name": 7107 if value != nil { 7108 jtv, ok := value.(string) 7109 if !ok { 7110 return fmt.Errorf("expected ArtifactName to be of type string, got %T instead", value) 7111 } 7112 sv.Name = ptr.String(jtv) 7113 } 7114 7115 case "revisionChangeIdentifier": 7116 if value != nil { 7117 jtv, ok := value.(string) 7118 if !ok { 7119 return fmt.Errorf("expected RevisionChangeIdentifier to be of type string, got %T instead", value) 7120 } 7121 sv.RevisionChangeIdentifier = ptr.String(jtv) 7122 } 7123 7124 case "revisionId": 7125 if value != nil { 7126 jtv, ok := value.(string) 7127 if !ok { 7128 return fmt.Errorf("expected Revision to be of type string, got %T instead", value) 7129 } 7130 sv.RevisionId = ptr.String(jtv) 7131 } 7132 7133 case "revisionSummary": 7134 if value != nil { 7135 jtv, ok := value.(string) 7136 if !ok { 7137 return fmt.Errorf("expected RevisionSummary to be of type string, got %T instead", value) 7138 } 7139 sv.RevisionSummary = ptr.String(jtv) 7140 } 7141 7142 case "revisionUrl": 7143 if value != nil { 7144 jtv, ok := value.(string) 7145 if !ok { 7146 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 7147 } 7148 sv.RevisionUrl = ptr.String(jtv) 7149 } 7150 7151 default: 7152 _, _ = key, value 7153 7154 } 7155 } 7156 *v = sv 7157 return nil 7158} 7159 7160func awsAwsjson11_deserializeDocumentArtifactRevisionList(v *[]types.ArtifactRevision, value interface{}) error { 7161 if v == nil { 7162 return fmt.Errorf("unexpected nil of type %T", v) 7163 } 7164 if value == nil { 7165 return nil 7166 } 7167 7168 shape, ok := value.([]interface{}) 7169 if !ok { 7170 return fmt.Errorf("unexpected JSON type %v", value) 7171 } 7172 7173 var cv []types.ArtifactRevision 7174 if *v == nil { 7175 cv = []types.ArtifactRevision{} 7176 } else { 7177 cv = *v 7178 } 7179 7180 for _, value := range shape { 7181 var col types.ArtifactRevision 7182 destAddr := &col 7183 if err := awsAwsjson11_deserializeDocumentArtifactRevision(&destAddr, value); err != nil { 7184 return err 7185 } 7186 col = *destAddr 7187 cv = append(cv, col) 7188 7189 } 7190 *v = cv 7191 return nil 7192} 7193 7194func awsAwsjson11_deserializeDocumentArtifactStore(v **types.ArtifactStore, value interface{}) error { 7195 if v == nil { 7196 return fmt.Errorf("unexpected nil of type %T", v) 7197 } 7198 if value == nil { 7199 return nil 7200 } 7201 7202 shape, ok := value.(map[string]interface{}) 7203 if !ok { 7204 return fmt.Errorf("unexpected JSON type %v", value) 7205 } 7206 7207 var sv *types.ArtifactStore 7208 if *v == nil { 7209 sv = &types.ArtifactStore{} 7210 } else { 7211 sv = *v 7212 } 7213 7214 for key, value := range shape { 7215 switch key { 7216 case "encryptionKey": 7217 if err := awsAwsjson11_deserializeDocumentEncryptionKey(&sv.EncryptionKey, value); err != nil { 7218 return err 7219 } 7220 7221 case "location": 7222 if value != nil { 7223 jtv, ok := value.(string) 7224 if !ok { 7225 return fmt.Errorf("expected ArtifactStoreLocation to be of type string, got %T instead", value) 7226 } 7227 sv.Location = ptr.String(jtv) 7228 } 7229 7230 case "type": 7231 if value != nil { 7232 jtv, ok := value.(string) 7233 if !ok { 7234 return fmt.Errorf("expected ArtifactStoreType to be of type string, got %T instead", value) 7235 } 7236 sv.Type = types.ArtifactStoreType(jtv) 7237 } 7238 7239 default: 7240 _, _ = key, value 7241 7242 } 7243 } 7244 *v = sv 7245 return nil 7246} 7247 7248func awsAwsjson11_deserializeDocumentArtifactStoreMap(v *map[string]types.ArtifactStore, value interface{}) error { 7249 if v == nil { 7250 return fmt.Errorf("unexpected nil of type %T", v) 7251 } 7252 if value == nil { 7253 return nil 7254 } 7255 7256 shape, ok := value.(map[string]interface{}) 7257 if !ok { 7258 return fmt.Errorf("unexpected JSON type %v", value) 7259 } 7260 7261 var mv map[string]types.ArtifactStore 7262 if *v == nil { 7263 mv = map[string]types.ArtifactStore{} 7264 } else { 7265 mv = *v 7266 } 7267 7268 for key, value := range shape { 7269 var parsedVal types.ArtifactStore 7270 mapVar := parsedVal 7271 destAddr := &mapVar 7272 if err := awsAwsjson11_deserializeDocumentArtifactStore(&destAddr, value); err != nil { 7273 return err 7274 } 7275 parsedVal = *destAddr 7276 mv[key] = parsedVal 7277 7278 } 7279 *v = mv 7280 return nil 7281} 7282 7283func awsAwsjson11_deserializeDocumentAWSSessionCredentials(v **types.AWSSessionCredentials, value interface{}) error { 7284 if v == nil { 7285 return fmt.Errorf("unexpected nil of type %T", v) 7286 } 7287 if value == nil { 7288 return nil 7289 } 7290 7291 shape, ok := value.(map[string]interface{}) 7292 if !ok { 7293 return fmt.Errorf("unexpected JSON type %v", value) 7294 } 7295 7296 var sv *types.AWSSessionCredentials 7297 if *v == nil { 7298 sv = &types.AWSSessionCredentials{} 7299 } else { 7300 sv = *v 7301 } 7302 7303 for key, value := range shape { 7304 switch key { 7305 case "accessKeyId": 7306 if value != nil { 7307 jtv, ok := value.(string) 7308 if !ok { 7309 return fmt.Errorf("expected AccessKeyId to be of type string, got %T instead", value) 7310 } 7311 sv.AccessKeyId = ptr.String(jtv) 7312 } 7313 7314 case "secretAccessKey": 7315 if value != nil { 7316 jtv, ok := value.(string) 7317 if !ok { 7318 return fmt.Errorf("expected SecretAccessKey to be of type string, got %T instead", value) 7319 } 7320 sv.SecretAccessKey = ptr.String(jtv) 7321 } 7322 7323 case "sessionToken": 7324 if value != nil { 7325 jtv, ok := value.(string) 7326 if !ok { 7327 return fmt.Errorf("expected SessionToken to be of type string, got %T instead", value) 7328 } 7329 sv.SessionToken = ptr.String(jtv) 7330 } 7331 7332 default: 7333 _, _ = key, value 7334 7335 } 7336 } 7337 *v = sv 7338 return nil 7339} 7340 7341func awsAwsjson11_deserializeDocumentBlockerDeclaration(v **types.BlockerDeclaration, value interface{}) error { 7342 if v == nil { 7343 return fmt.Errorf("unexpected nil of type %T", v) 7344 } 7345 if value == nil { 7346 return nil 7347 } 7348 7349 shape, ok := value.(map[string]interface{}) 7350 if !ok { 7351 return fmt.Errorf("unexpected JSON type %v", value) 7352 } 7353 7354 var sv *types.BlockerDeclaration 7355 if *v == nil { 7356 sv = &types.BlockerDeclaration{} 7357 } else { 7358 sv = *v 7359 } 7360 7361 for key, value := range shape { 7362 switch key { 7363 case "name": 7364 if value != nil { 7365 jtv, ok := value.(string) 7366 if !ok { 7367 return fmt.Errorf("expected BlockerName to be of type string, got %T instead", value) 7368 } 7369 sv.Name = ptr.String(jtv) 7370 } 7371 7372 case "type": 7373 if value != nil { 7374 jtv, ok := value.(string) 7375 if !ok { 7376 return fmt.Errorf("expected BlockerType to be of type string, got %T instead", value) 7377 } 7378 sv.Type = types.BlockerType(jtv) 7379 } 7380 7381 default: 7382 _, _ = key, value 7383 7384 } 7385 } 7386 *v = sv 7387 return nil 7388} 7389 7390func awsAwsjson11_deserializeDocumentConcurrentModificationException(v **types.ConcurrentModificationException, value interface{}) error { 7391 if v == nil { 7392 return fmt.Errorf("unexpected nil of type %T", v) 7393 } 7394 if value == nil { 7395 return nil 7396 } 7397 7398 shape, ok := value.(map[string]interface{}) 7399 if !ok { 7400 return fmt.Errorf("unexpected JSON type %v", value) 7401 } 7402 7403 var sv *types.ConcurrentModificationException 7404 if *v == nil { 7405 sv = &types.ConcurrentModificationException{} 7406 } else { 7407 sv = *v 7408 } 7409 7410 for key, value := range shape { 7411 switch key { 7412 case "message": 7413 if value != nil { 7414 jtv, ok := value.(string) 7415 if !ok { 7416 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7417 } 7418 sv.Message = ptr.String(jtv) 7419 } 7420 7421 default: 7422 _, _ = key, value 7423 7424 } 7425 } 7426 *v = sv 7427 return nil 7428} 7429 7430func awsAwsjson11_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { 7431 if v == nil { 7432 return fmt.Errorf("unexpected nil of type %T", v) 7433 } 7434 if value == nil { 7435 return nil 7436 } 7437 7438 shape, ok := value.(map[string]interface{}) 7439 if !ok { 7440 return fmt.Errorf("unexpected JSON type %v", value) 7441 } 7442 7443 var sv *types.ConflictException 7444 if *v == nil { 7445 sv = &types.ConflictException{} 7446 } else { 7447 sv = *v 7448 } 7449 7450 for key, value := range shape { 7451 switch key { 7452 case "message": 7453 if value != nil { 7454 jtv, ok := value.(string) 7455 if !ok { 7456 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7457 } 7458 sv.Message = ptr.String(jtv) 7459 } 7460 7461 default: 7462 _, _ = key, value 7463 7464 } 7465 } 7466 *v = sv 7467 return nil 7468} 7469 7470func awsAwsjson11_deserializeDocumentDuplicatedStopRequestException(v **types.DuplicatedStopRequestException, value interface{}) error { 7471 if v == nil { 7472 return fmt.Errorf("unexpected nil of type %T", v) 7473 } 7474 if value == nil { 7475 return nil 7476 } 7477 7478 shape, ok := value.(map[string]interface{}) 7479 if !ok { 7480 return fmt.Errorf("unexpected JSON type %v", value) 7481 } 7482 7483 var sv *types.DuplicatedStopRequestException 7484 if *v == nil { 7485 sv = &types.DuplicatedStopRequestException{} 7486 } else { 7487 sv = *v 7488 } 7489 7490 for key, value := range shape { 7491 switch key { 7492 case "message": 7493 if value != nil { 7494 jtv, ok := value.(string) 7495 if !ok { 7496 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7497 } 7498 sv.Message = ptr.String(jtv) 7499 } 7500 7501 default: 7502 _, _ = key, value 7503 7504 } 7505 } 7506 *v = sv 7507 return nil 7508} 7509 7510func awsAwsjson11_deserializeDocumentEncryptionKey(v **types.EncryptionKey, value interface{}) error { 7511 if v == nil { 7512 return fmt.Errorf("unexpected nil of type %T", v) 7513 } 7514 if value == nil { 7515 return nil 7516 } 7517 7518 shape, ok := value.(map[string]interface{}) 7519 if !ok { 7520 return fmt.Errorf("unexpected JSON type %v", value) 7521 } 7522 7523 var sv *types.EncryptionKey 7524 if *v == nil { 7525 sv = &types.EncryptionKey{} 7526 } else { 7527 sv = *v 7528 } 7529 7530 for key, value := range shape { 7531 switch key { 7532 case "id": 7533 if value != nil { 7534 jtv, ok := value.(string) 7535 if !ok { 7536 return fmt.Errorf("expected EncryptionKeyId to be of type string, got %T instead", value) 7537 } 7538 sv.Id = ptr.String(jtv) 7539 } 7540 7541 case "type": 7542 if value != nil { 7543 jtv, ok := value.(string) 7544 if !ok { 7545 return fmt.Errorf("expected EncryptionKeyType to be of type string, got %T instead", value) 7546 } 7547 sv.Type = types.EncryptionKeyType(jtv) 7548 } 7549 7550 default: 7551 _, _ = key, value 7552 7553 } 7554 } 7555 *v = sv 7556 return nil 7557} 7558 7559func awsAwsjson11_deserializeDocumentErrorDetails(v **types.ErrorDetails, value interface{}) error { 7560 if v == nil { 7561 return fmt.Errorf("unexpected nil of type %T", v) 7562 } 7563 if value == nil { 7564 return nil 7565 } 7566 7567 shape, ok := value.(map[string]interface{}) 7568 if !ok { 7569 return fmt.Errorf("unexpected JSON type %v", value) 7570 } 7571 7572 var sv *types.ErrorDetails 7573 if *v == nil { 7574 sv = &types.ErrorDetails{} 7575 } else { 7576 sv = *v 7577 } 7578 7579 for key, value := range shape { 7580 switch key { 7581 case "code": 7582 if value != nil { 7583 jtv, ok := value.(string) 7584 if !ok { 7585 return fmt.Errorf("expected Code to be of type string, got %T instead", value) 7586 } 7587 sv.Code = ptr.String(jtv) 7588 } 7589 7590 case "message": 7591 if value != nil { 7592 jtv, ok := value.(string) 7593 if !ok { 7594 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7595 } 7596 sv.Message = ptr.String(jtv) 7597 } 7598 7599 default: 7600 _, _ = key, value 7601 7602 } 7603 } 7604 *v = sv 7605 return nil 7606} 7607 7608func awsAwsjson11_deserializeDocumentExecutionTrigger(v **types.ExecutionTrigger, value interface{}) error { 7609 if v == nil { 7610 return fmt.Errorf("unexpected nil of type %T", v) 7611 } 7612 if value == nil { 7613 return nil 7614 } 7615 7616 shape, ok := value.(map[string]interface{}) 7617 if !ok { 7618 return fmt.Errorf("unexpected JSON type %v", value) 7619 } 7620 7621 var sv *types.ExecutionTrigger 7622 if *v == nil { 7623 sv = &types.ExecutionTrigger{} 7624 } else { 7625 sv = *v 7626 } 7627 7628 for key, value := range shape { 7629 switch key { 7630 case "triggerDetail": 7631 if value != nil { 7632 jtv, ok := value.(string) 7633 if !ok { 7634 return fmt.Errorf("expected TriggerDetail to be of type string, got %T instead", value) 7635 } 7636 sv.TriggerDetail = ptr.String(jtv) 7637 } 7638 7639 case "triggerType": 7640 if value != nil { 7641 jtv, ok := value.(string) 7642 if !ok { 7643 return fmt.Errorf("expected TriggerType to be of type string, got %T instead", value) 7644 } 7645 sv.TriggerType = types.TriggerType(jtv) 7646 } 7647 7648 default: 7649 _, _ = key, value 7650 7651 } 7652 } 7653 *v = sv 7654 return nil 7655} 7656 7657func awsAwsjson11_deserializeDocumentInputArtifact(v **types.InputArtifact, value interface{}) error { 7658 if v == nil { 7659 return fmt.Errorf("unexpected nil of type %T", v) 7660 } 7661 if value == nil { 7662 return nil 7663 } 7664 7665 shape, ok := value.(map[string]interface{}) 7666 if !ok { 7667 return fmt.Errorf("unexpected JSON type %v", value) 7668 } 7669 7670 var sv *types.InputArtifact 7671 if *v == nil { 7672 sv = &types.InputArtifact{} 7673 } else { 7674 sv = *v 7675 } 7676 7677 for key, value := range shape { 7678 switch key { 7679 case "name": 7680 if value != nil { 7681 jtv, ok := value.(string) 7682 if !ok { 7683 return fmt.Errorf("expected ArtifactName to be of type string, got %T instead", value) 7684 } 7685 sv.Name = ptr.String(jtv) 7686 } 7687 7688 default: 7689 _, _ = key, value 7690 7691 } 7692 } 7693 *v = sv 7694 return nil 7695} 7696 7697func awsAwsjson11_deserializeDocumentInputArtifactList(v *[]types.InputArtifact, value interface{}) error { 7698 if v == nil { 7699 return fmt.Errorf("unexpected nil of type %T", v) 7700 } 7701 if value == nil { 7702 return nil 7703 } 7704 7705 shape, ok := value.([]interface{}) 7706 if !ok { 7707 return fmt.Errorf("unexpected JSON type %v", value) 7708 } 7709 7710 var cv []types.InputArtifact 7711 if *v == nil { 7712 cv = []types.InputArtifact{} 7713 } else { 7714 cv = *v 7715 } 7716 7717 for _, value := range shape { 7718 var col types.InputArtifact 7719 destAddr := &col 7720 if err := awsAwsjson11_deserializeDocumentInputArtifact(&destAddr, value); err != nil { 7721 return err 7722 } 7723 col = *destAddr 7724 cv = append(cv, col) 7725 7726 } 7727 *v = cv 7728 return nil 7729} 7730 7731func awsAwsjson11_deserializeDocumentInvalidActionDeclarationException(v **types.InvalidActionDeclarationException, value interface{}) error { 7732 if v == nil { 7733 return fmt.Errorf("unexpected nil of type %T", v) 7734 } 7735 if value == nil { 7736 return nil 7737 } 7738 7739 shape, ok := value.(map[string]interface{}) 7740 if !ok { 7741 return fmt.Errorf("unexpected JSON type %v", value) 7742 } 7743 7744 var sv *types.InvalidActionDeclarationException 7745 if *v == nil { 7746 sv = &types.InvalidActionDeclarationException{} 7747 } else { 7748 sv = *v 7749 } 7750 7751 for key, value := range shape { 7752 switch key { 7753 case "message": 7754 if value != nil { 7755 jtv, ok := value.(string) 7756 if !ok { 7757 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7758 } 7759 sv.Message = ptr.String(jtv) 7760 } 7761 7762 default: 7763 _, _ = key, value 7764 7765 } 7766 } 7767 *v = sv 7768 return nil 7769} 7770 7771func awsAwsjson11_deserializeDocumentInvalidApprovalTokenException(v **types.InvalidApprovalTokenException, value interface{}) error { 7772 if v == nil { 7773 return fmt.Errorf("unexpected nil of type %T", v) 7774 } 7775 if value == nil { 7776 return nil 7777 } 7778 7779 shape, ok := value.(map[string]interface{}) 7780 if !ok { 7781 return fmt.Errorf("unexpected JSON type %v", value) 7782 } 7783 7784 var sv *types.InvalidApprovalTokenException 7785 if *v == nil { 7786 sv = &types.InvalidApprovalTokenException{} 7787 } else { 7788 sv = *v 7789 } 7790 7791 for key, value := range shape { 7792 switch key { 7793 case "message": 7794 if value != nil { 7795 jtv, ok := value.(string) 7796 if !ok { 7797 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7798 } 7799 sv.Message = ptr.String(jtv) 7800 } 7801 7802 default: 7803 _, _ = key, value 7804 7805 } 7806 } 7807 *v = sv 7808 return nil 7809} 7810 7811func awsAwsjson11_deserializeDocumentInvalidArnException(v **types.InvalidArnException, value interface{}) error { 7812 if v == nil { 7813 return fmt.Errorf("unexpected nil of type %T", v) 7814 } 7815 if value == nil { 7816 return nil 7817 } 7818 7819 shape, ok := value.(map[string]interface{}) 7820 if !ok { 7821 return fmt.Errorf("unexpected JSON type %v", value) 7822 } 7823 7824 var sv *types.InvalidArnException 7825 if *v == nil { 7826 sv = &types.InvalidArnException{} 7827 } else { 7828 sv = *v 7829 } 7830 7831 for key, value := range shape { 7832 switch key { 7833 case "message": 7834 if value != nil { 7835 jtv, ok := value.(string) 7836 if !ok { 7837 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7838 } 7839 sv.Message = ptr.String(jtv) 7840 } 7841 7842 default: 7843 _, _ = key, value 7844 7845 } 7846 } 7847 *v = sv 7848 return nil 7849} 7850 7851func awsAwsjson11_deserializeDocumentInvalidBlockerDeclarationException(v **types.InvalidBlockerDeclarationException, value interface{}) error { 7852 if v == nil { 7853 return fmt.Errorf("unexpected nil of type %T", v) 7854 } 7855 if value == nil { 7856 return nil 7857 } 7858 7859 shape, ok := value.(map[string]interface{}) 7860 if !ok { 7861 return fmt.Errorf("unexpected JSON type %v", value) 7862 } 7863 7864 var sv *types.InvalidBlockerDeclarationException 7865 if *v == nil { 7866 sv = &types.InvalidBlockerDeclarationException{} 7867 } else { 7868 sv = *v 7869 } 7870 7871 for key, value := range shape { 7872 switch key { 7873 case "message": 7874 if value != nil { 7875 jtv, ok := value.(string) 7876 if !ok { 7877 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7878 } 7879 sv.Message = ptr.String(jtv) 7880 } 7881 7882 default: 7883 _, _ = key, value 7884 7885 } 7886 } 7887 *v = sv 7888 return nil 7889} 7890 7891func awsAwsjson11_deserializeDocumentInvalidClientTokenException(v **types.InvalidClientTokenException, value interface{}) error { 7892 if v == nil { 7893 return fmt.Errorf("unexpected nil of type %T", v) 7894 } 7895 if value == nil { 7896 return nil 7897 } 7898 7899 shape, ok := value.(map[string]interface{}) 7900 if !ok { 7901 return fmt.Errorf("unexpected JSON type %v", value) 7902 } 7903 7904 var sv *types.InvalidClientTokenException 7905 if *v == nil { 7906 sv = &types.InvalidClientTokenException{} 7907 } else { 7908 sv = *v 7909 } 7910 7911 for key, value := range shape { 7912 switch key { 7913 case "message": 7914 if value != nil { 7915 jtv, ok := value.(string) 7916 if !ok { 7917 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7918 } 7919 sv.Message = ptr.String(jtv) 7920 } 7921 7922 default: 7923 _, _ = key, value 7924 7925 } 7926 } 7927 *v = sv 7928 return nil 7929} 7930 7931func awsAwsjson11_deserializeDocumentInvalidJobException(v **types.InvalidJobException, value interface{}) error { 7932 if v == nil { 7933 return fmt.Errorf("unexpected nil of type %T", v) 7934 } 7935 if value == nil { 7936 return nil 7937 } 7938 7939 shape, ok := value.(map[string]interface{}) 7940 if !ok { 7941 return fmt.Errorf("unexpected JSON type %v", value) 7942 } 7943 7944 var sv *types.InvalidJobException 7945 if *v == nil { 7946 sv = &types.InvalidJobException{} 7947 } else { 7948 sv = *v 7949 } 7950 7951 for key, value := range shape { 7952 switch key { 7953 case "message": 7954 if value != nil { 7955 jtv, ok := value.(string) 7956 if !ok { 7957 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7958 } 7959 sv.Message = ptr.String(jtv) 7960 } 7961 7962 default: 7963 _, _ = key, value 7964 7965 } 7966 } 7967 *v = sv 7968 return nil 7969} 7970 7971func awsAwsjson11_deserializeDocumentInvalidJobStateException(v **types.InvalidJobStateException, value interface{}) error { 7972 if v == nil { 7973 return fmt.Errorf("unexpected nil of type %T", v) 7974 } 7975 if value == nil { 7976 return nil 7977 } 7978 7979 shape, ok := value.(map[string]interface{}) 7980 if !ok { 7981 return fmt.Errorf("unexpected JSON type %v", value) 7982 } 7983 7984 var sv *types.InvalidJobStateException 7985 if *v == nil { 7986 sv = &types.InvalidJobStateException{} 7987 } else { 7988 sv = *v 7989 } 7990 7991 for key, value := range shape { 7992 switch key { 7993 case "message": 7994 if value != nil { 7995 jtv, ok := value.(string) 7996 if !ok { 7997 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 7998 } 7999 sv.Message = ptr.String(jtv) 8000 } 8001 8002 default: 8003 _, _ = key, value 8004 8005 } 8006 } 8007 *v = sv 8008 return nil 8009} 8010 8011func awsAwsjson11_deserializeDocumentInvalidNextTokenException(v **types.InvalidNextTokenException, value interface{}) error { 8012 if v == nil { 8013 return fmt.Errorf("unexpected nil of type %T", v) 8014 } 8015 if value == nil { 8016 return nil 8017 } 8018 8019 shape, ok := value.(map[string]interface{}) 8020 if !ok { 8021 return fmt.Errorf("unexpected JSON type %v", value) 8022 } 8023 8024 var sv *types.InvalidNextTokenException 8025 if *v == nil { 8026 sv = &types.InvalidNextTokenException{} 8027 } else { 8028 sv = *v 8029 } 8030 8031 for key, value := range shape { 8032 switch key { 8033 case "message": 8034 if value != nil { 8035 jtv, ok := value.(string) 8036 if !ok { 8037 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8038 } 8039 sv.Message = ptr.String(jtv) 8040 } 8041 8042 default: 8043 _, _ = key, value 8044 8045 } 8046 } 8047 *v = sv 8048 return nil 8049} 8050 8051func awsAwsjson11_deserializeDocumentInvalidNonceException(v **types.InvalidNonceException, 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.InvalidNonceException 8065 if *v == nil { 8066 sv = &types.InvalidNonceException{} 8067 } else { 8068 sv = *v 8069 } 8070 8071 for key, value := range shape { 8072 switch key { 8073 case "message": 8074 if value != nil { 8075 jtv, ok := value.(string) 8076 if !ok { 8077 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8078 } 8079 sv.Message = ptr.String(jtv) 8080 } 8081 8082 default: 8083 _, _ = key, value 8084 8085 } 8086 } 8087 *v = sv 8088 return nil 8089} 8090 8091func awsAwsjson11_deserializeDocumentInvalidStageDeclarationException(v **types.InvalidStageDeclarationException, value interface{}) error { 8092 if v == nil { 8093 return fmt.Errorf("unexpected nil of type %T", v) 8094 } 8095 if value == nil { 8096 return nil 8097 } 8098 8099 shape, ok := value.(map[string]interface{}) 8100 if !ok { 8101 return fmt.Errorf("unexpected JSON type %v", value) 8102 } 8103 8104 var sv *types.InvalidStageDeclarationException 8105 if *v == nil { 8106 sv = &types.InvalidStageDeclarationException{} 8107 } else { 8108 sv = *v 8109 } 8110 8111 for key, value := range shape { 8112 switch key { 8113 case "message": 8114 if value != nil { 8115 jtv, ok := value.(string) 8116 if !ok { 8117 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8118 } 8119 sv.Message = ptr.String(jtv) 8120 } 8121 8122 default: 8123 _, _ = key, value 8124 8125 } 8126 } 8127 *v = sv 8128 return nil 8129} 8130 8131func awsAwsjson11_deserializeDocumentInvalidStructureException(v **types.InvalidStructureException, value interface{}) error { 8132 if v == nil { 8133 return fmt.Errorf("unexpected nil of type %T", v) 8134 } 8135 if value == nil { 8136 return nil 8137 } 8138 8139 shape, ok := value.(map[string]interface{}) 8140 if !ok { 8141 return fmt.Errorf("unexpected JSON type %v", value) 8142 } 8143 8144 var sv *types.InvalidStructureException 8145 if *v == nil { 8146 sv = &types.InvalidStructureException{} 8147 } else { 8148 sv = *v 8149 } 8150 8151 for key, value := range shape { 8152 switch key { 8153 case "message": 8154 if value != nil { 8155 jtv, ok := value.(string) 8156 if !ok { 8157 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8158 } 8159 sv.Message = ptr.String(jtv) 8160 } 8161 8162 default: 8163 _, _ = key, value 8164 8165 } 8166 } 8167 *v = sv 8168 return nil 8169} 8170 8171func awsAwsjson11_deserializeDocumentInvalidTagsException(v **types.InvalidTagsException, value interface{}) error { 8172 if v == nil { 8173 return fmt.Errorf("unexpected nil of type %T", v) 8174 } 8175 if value == nil { 8176 return nil 8177 } 8178 8179 shape, ok := value.(map[string]interface{}) 8180 if !ok { 8181 return fmt.Errorf("unexpected JSON type %v", value) 8182 } 8183 8184 var sv *types.InvalidTagsException 8185 if *v == nil { 8186 sv = &types.InvalidTagsException{} 8187 } else { 8188 sv = *v 8189 } 8190 8191 for key, value := range shape { 8192 switch key { 8193 case "message": 8194 if value != nil { 8195 jtv, ok := value.(string) 8196 if !ok { 8197 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8198 } 8199 sv.Message = ptr.String(jtv) 8200 } 8201 8202 default: 8203 _, _ = key, value 8204 8205 } 8206 } 8207 *v = sv 8208 return nil 8209} 8210 8211func awsAwsjson11_deserializeDocumentInvalidWebhookAuthenticationParametersException(v **types.InvalidWebhookAuthenticationParametersException, value interface{}) error { 8212 if v == nil { 8213 return fmt.Errorf("unexpected nil of type %T", v) 8214 } 8215 if value == nil { 8216 return nil 8217 } 8218 8219 shape, ok := value.(map[string]interface{}) 8220 if !ok { 8221 return fmt.Errorf("unexpected JSON type %v", value) 8222 } 8223 8224 var sv *types.InvalidWebhookAuthenticationParametersException 8225 if *v == nil { 8226 sv = &types.InvalidWebhookAuthenticationParametersException{} 8227 } else { 8228 sv = *v 8229 } 8230 8231 for key, value := range shape { 8232 switch key { 8233 case "message": 8234 if value != nil { 8235 jtv, ok := value.(string) 8236 if !ok { 8237 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8238 } 8239 sv.Message = ptr.String(jtv) 8240 } 8241 8242 default: 8243 _, _ = key, value 8244 8245 } 8246 } 8247 *v = sv 8248 return nil 8249} 8250 8251func awsAwsjson11_deserializeDocumentInvalidWebhookFilterPatternException(v **types.InvalidWebhookFilterPatternException, value interface{}) error { 8252 if v == nil { 8253 return fmt.Errorf("unexpected nil of type %T", v) 8254 } 8255 if value == nil { 8256 return nil 8257 } 8258 8259 shape, ok := value.(map[string]interface{}) 8260 if !ok { 8261 return fmt.Errorf("unexpected JSON type %v", value) 8262 } 8263 8264 var sv *types.InvalidWebhookFilterPatternException 8265 if *v == nil { 8266 sv = &types.InvalidWebhookFilterPatternException{} 8267 } else { 8268 sv = *v 8269 } 8270 8271 for key, value := range shape { 8272 switch key { 8273 case "message": 8274 if value != nil { 8275 jtv, ok := value.(string) 8276 if !ok { 8277 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8278 } 8279 sv.Message = ptr.String(jtv) 8280 } 8281 8282 default: 8283 _, _ = key, value 8284 8285 } 8286 } 8287 *v = sv 8288 return nil 8289} 8290 8291func awsAwsjson11_deserializeDocumentJob(v **types.Job, value interface{}) error { 8292 if v == nil { 8293 return fmt.Errorf("unexpected nil of type %T", v) 8294 } 8295 if value == nil { 8296 return nil 8297 } 8298 8299 shape, ok := value.(map[string]interface{}) 8300 if !ok { 8301 return fmt.Errorf("unexpected JSON type %v", value) 8302 } 8303 8304 var sv *types.Job 8305 if *v == nil { 8306 sv = &types.Job{} 8307 } else { 8308 sv = *v 8309 } 8310 8311 for key, value := range shape { 8312 switch key { 8313 case "accountId": 8314 if value != nil { 8315 jtv, ok := value.(string) 8316 if !ok { 8317 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 8318 } 8319 sv.AccountId = ptr.String(jtv) 8320 } 8321 8322 case "data": 8323 if err := awsAwsjson11_deserializeDocumentJobData(&sv.Data, value); err != nil { 8324 return err 8325 } 8326 8327 case "id": 8328 if value != nil { 8329 jtv, ok := value.(string) 8330 if !ok { 8331 return fmt.Errorf("expected JobId to be of type string, got %T instead", value) 8332 } 8333 sv.Id = ptr.String(jtv) 8334 } 8335 8336 case "nonce": 8337 if value != nil { 8338 jtv, ok := value.(string) 8339 if !ok { 8340 return fmt.Errorf("expected Nonce to be of type string, got %T instead", value) 8341 } 8342 sv.Nonce = ptr.String(jtv) 8343 } 8344 8345 default: 8346 _, _ = key, value 8347 8348 } 8349 } 8350 *v = sv 8351 return nil 8352} 8353 8354func awsAwsjson11_deserializeDocumentJobData(v **types.JobData, value interface{}) error { 8355 if v == nil { 8356 return fmt.Errorf("unexpected nil of type %T", v) 8357 } 8358 if value == nil { 8359 return nil 8360 } 8361 8362 shape, ok := value.(map[string]interface{}) 8363 if !ok { 8364 return fmt.Errorf("unexpected JSON type %v", value) 8365 } 8366 8367 var sv *types.JobData 8368 if *v == nil { 8369 sv = &types.JobData{} 8370 } else { 8371 sv = *v 8372 } 8373 8374 for key, value := range shape { 8375 switch key { 8376 case "actionConfiguration": 8377 if err := awsAwsjson11_deserializeDocumentActionConfiguration(&sv.ActionConfiguration, value); err != nil { 8378 return err 8379 } 8380 8381 case "actionTypeId": 8382 if err := awsAwsjson11_deserializeDocumentActionTypeId(&sv.ActionTypeId, value); err != nil { 8383 return err 8384 } 8385 8386 case "artifactCredentials": 8387 if err := awsAwsjson11_deserializeDocumentAWSSessionCredentials(&sv.ArtifactCredentials, value); err != nil { 8388 return err 8389 } 8390 8391 case "continuationToken": 8392 if value != nil { 8393 jtv, ok := value.(string) 8394 if !ok { 8395 return fmt.Errorf("expected ContinuationToken to be of type string, got %T instead", value) 8396 } 8397 sv.ContinuationToken = ptr.String(jtv) 8398 } 8399 8400 case "encryptionKey": 8401 if err := awsAwsjson11_deserializeDocumentEncryptionKey(&sv.EncryptionKey, value); err != nil { 8402 return err 8403 } 8404 8405 case "inputArtifacts": 8406 if err := awsAwsjson11_deserializeDocumentArtifactList(&sv.InputArtifacts, value); err != nil { 8407 return err 8408 } 8409 8410 case "outputArtifacts": 8411 if err := awsAwsjson11_deserializeDocumentArtifactList(&sv.OutputArtifacts, value); err != nil { 8412 return err 8413 } 8414 8415 case "pipelineContext": 8416 if err := awsAwsjson11_deserializeDocumentPipelineContext(&sv.PipelineContext, value); err != nil { 8417 return err 8418 } 8419 8420 default: 8421 _, _ = key, value 8422 8423 } 8424 } 8425 *v = sv 8426 return nil 8427} 8428 8429func awsAwsjson11_deserializeDocumentJobDetails(v **types.JobDetails, value interface{}) error { 8430 if v == nil { 8431 return fmt.Errorf("unexpected nil of type %T", v) 8432 } 8433 if value == nil { 8434 return nil 8435 } 8436 8437 shape, ok := value.(map[string]interface{}) 8438 if !ok { 8439 return fmt.Errorf("unexpected JSON type %v", value) 8440 } 8441 8442 var sv *types.JobDetails 8443 if *v == nil { 8444 sv = &types.JobDetails{} 8445 } else { 8446 sv = *v 8447 } 8448 8449 for key, value := range shape { 8450 switch key { 8451 case "accountId": 8452 if value != nil { 8453 jtv, ok := value.(string) 8454 if !ok { 8455 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 8456 } 8457 sv.AccountId = ptr.String(jtv) 8458 } 8459 8460 case "data": 8461 if err := awsAwsjson11_deserializeDocumentJobData(&sv.Data, value); err != nil { 8462 return err 8463 } 8464 8465 case "id": 8466 if value != nil { 8467 jtv, ok := value.(string) 8468 if !ok { 8469 return fmt.Errorf("expected JobId to be of type string, got %T instead", value) 8470 } 8471 sv.Id = ptr.String(jtv) 8472 } 8473 8474 default: 8475 _, _ = key, value 8476 8477 } 8478 } 8479 *v = sv 8480 return nil 8481} 8482 8483func awsAwsjson11_deserializeDocumentJobList(v *[]types.Job, value interface{}) error { 8484 if v == nil { 8485 return fmt.Errorf("unexpected nil of type %T", v) 8486 } 8487 if value == nil { 8488 return nil 8489 } 8490 8491 shape, ok := value.([]interface{}) 8492 if !ok { 8493 return fmt.Errorf("unexpected JSON type %v", value) 8494 } 8495 8496 var cv []types.Job 8497 if *v == nil { 8498 cv = []types.Job{} 8499 } else { 8500 cv = *v 8501 } 8502 8503 for _, value := range shape { 8504 var col types.Job 8505 destAddr := &col 8506 if err := awsAwsjson11_deserializeDocumentJob(&destAddr, value); err != nil { 8507 return err 8508 } 8509 col = *destAddr 8510 cv = append(cv, col) 8511 8512 } 8513 *v = cv 8514 return nil 8515} 8516 8517func awsAwsjson11_deserializeDocumentJobNotFoundException(v **types.JobNotFoundException, value interface{}) error { 8518 if v == nil { 8519 return fmt.Errorf("unexpected nil of type %T", v) 8520 } 8521 if value == nil { 8522 return nil 8523 } 8524 8525 shape, ok := value.(map[string]interface{}) 8526 if !ok { 8527 return fmt.Errorf("unexpected JSON type %v", value) 8528 } 8529 8530 var sv *types.JobNotFoundException 8531 if *v == nil { 8532 sv = &types.JobNotFoundException{} 8533 } else { 8534 sv = *v 8535 } 8536 8537 for key, value := range shape { 8538 switch key { 8539 case "message": 8540 if value != nil { 8541 jtv, ok := value.(string) 8542 if !ok { 8543 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8544 } 8545 sv.Message = ptr.String(jtv) 8546 } 8547 8548 default: 8549 _, _ = key, value 8550 8551 } 8552 } 8553 *v = sv 8554 return nil 8555} 8556 8557func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { 8558 if v == nil { 8559 return fmt.Errorf("unexpected nil of type %T", v) 8560 } 8561 if value == nil { 8562 return nil 8563 } 8564 8565 shape, ok := value.(map[string]interface{}) 8566 if !ok { 8567 return fmt.Errorf("unexpected JSON type %v", value) 8568 } 8569 8570 var sv *types.LimitExceededException 8571 if *v == nil { 8572 sv = &types.LimitExceededException{} 8573 } else { 8574 sv = *v 8575 } 8576 8577 for key, value := range shape { 8578 switch key { 8579 case "message": 8580 if value != nil { 8581 jtv, ok := value.(string) 8582 if !ok { 8583 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8584 } 8585 sv.Message = ptr.String(jtv) 8586 } 8587 8588 default: 8589 _, _ = key, value 8590 8591 } 8592 } 8593 *v = sv 8594 return nil 8595} 8596 8597func awsAwsjson11_deserializeDocumentListWebhookItem(v **types.ListWebhookItem, value interface{}) error { 8598 if v == nil { 8599 return fmt.Errorf("unexpected nil of type %T", v) 8600 } 8601 if value == nil { 8602 return nil 8603 } 8604 8605 shape, ok := value.(map[string]interface{}) 8606 if !ok { 8607 return fmt.Errorf("unexpected JSON type %v", value) 8608 } 8609 8610 var sv *types.ListWebhookItem 8611 if *v == nil { 8612 sv = &types.ListWebhookItem{} 8613 } else { 8614 sv = *v 8615 } 8616 8617 for key, value := range shape { 8618 switch key { 8619 case "arn": 8620 if value != nil { 8621 jtv, ok := value.(string) 8622 if !ok { 8623 return fmt.Errorf("expected WebhookArn to be of type string, got %T instead", value) 8624 } 8625 sv.Arn = ptr.String(jtv) 8626 } 8627 8628 case "definition": 8629 if err := awsAwsjson11_deserializeDocumentWebhookDefinition(&sv.Definition, value); err != nil { 8630 return err 8631 } 8632 8633 case "errorCode": 8634 if value != nil { 8635 jtv, ok := value.(string) 8636 if !ok { 8637 return fmt.Errorf("expected WebhookErrorCode to be of type string, got %T instead", value) 8638 } 8639 sv.ErrorCode = ptr.String(jtv) 8640 } 8641 8642 case "errorMessage": 8643 if value != nil { 8644 jtv, ok := value.(string) 8645 if !ok { 8646 return fmt.Errorf("expected WebhookErrorMessage to be of type string, got %T instead", value) 8647 } 8648 sv.ErrorMessage = ptr.String(jtv) 8649 } 8650 8651 case "lastTriggered": 8652 if value != nil { 8653 jtv, ok := value.(json.Number) 8654 if !ok { 8655 return fmt.Errorf("expected WebhookLastTriggered to be json.Number, got %T instead", value) 8656 } 8657 f64, err := jtv.Float64() 8658 if err != nil { 8659 return err 8660 } 8661 sv.LastTriggered = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8662 } 8663 8664 case "tags": 8665 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil { 8666 return err 8667 } 8668 8669 case "url": 8670 if value != nil { 8671 jtv, ok := value.(string) 8672 if !ok { 8673 return fmt.Errorf("expected WebhookUrl to be of type string, got %T instead", value) 8674 } 8675 sv.Url = ptr.String(jtv) 8676 } 8677 8678 default: 8679 _, _ = key, value 8680 8681 } 8682 } 8683 *v = sv 8684 return nil 8685} 8686 8687func awsAwsjson11_deserializeDocumentNotLatestPipelineExecutionException(v **types.NotLatestPipelineExecutionException, value interface{}) error { 8688 if v == nil { 8689 return fmt.Errorf("unexpected nil of type %T", v) 8690 } 8691 if value == nil { 8692 return nil 8693 } 8694 8695 shape, ok := value.(map[string]interface{}) 8696 if !ok { 8697 return fmt.Errorf("unexpected JSON type %v", value) 8698 } 8699 8700 var sv *types.NotLatestPipelineExecutionException 8701 if *v == nil { 8702 sv = &types.NotLatestPipelineExecutionException{} 8703 } else { 8704 sv = *v 8705 } 8706 8707 for key, value := range shape { 8708 switch key { 8709 case "message": 8710 if value != nil { 8711 jtv, ok := value.(string) 8712 if !ok { 8713 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8714 } 8715 sv.Message = ptr.String(jtv) 8716 } 8717 8718 default: 8719 _, _ = key, value 8720 8721 } 8722 } 8723 *v = sv 8724 return nil 8725} 8726 8727func awsAwsjson11_deserializeDocumentOutputArtifact(v **types.OutputArtifact, value interface{}) error { 8728 if v == nil { 8729 return fmt.Errorf("unexpected nil of type %T", v) 8730 } 8731 if value == nil { 8732 return nil 8733 } 8734 8735 shape, ok := value.(map[string]interface{}) 8736 if !ok { 8737 return fmt.Errorf("unexpected JSON type %v", value) 8738 } 8739 8740 var sv *types.OutputArtifact 8741 if *v == nil { 8742 sv = &types.OutputArtifact{} 8743 } else { 8744 sv = *v 8745 } 8746 8747 for key, value := range shape { 8748 switch key { 8749 case "name": 8750 if value != nil { 8751 jtv, ok := value.(string) 8752 if !ok { 8753 return fmt.Errorf("expected ArtifactName to be of type string, got %T instead", value) 8754 } 8755 sv.Name = ptr.String(jtv) 8756 } 8757 8758 default: 8759 _, _ = key, value 8760 8761 } 8762 } 8763 *v = sv 8764 return nil 8765} 8766 8767func awsAwsjson11_deserializeDocumentOutputArtifactList(v *[]types.OutputArtifact, value interface{}) error { 8768 if v == nil { 8769 return fmt.Errorf("unexpected nil of type %T", v) 8770 } 8771 if value == nil { 8772 return nil 8773 } 8774 8775 shape, ok := value.([]interface{}) 8776 if !ok { 8777 return fmt.Errorf("unexpected JSON type %v", value) 8778 } 8779 8780 var cv []types.OutputArtifact 8781 if *v == nil { 8782 cv = []types.OutputArtifact{} 8783 } else { 8784 cv = *v 8785 } 8786 8787 for _, value := range shape { 8788 var col types.OutputArtifact 8789 destAddr := &col 8790 if err := awsAwsjson11_deserializeDocumentOutputArtifact(&destAddr, value); err != nil { 8791 return err 8792 } 8793 col = *destAddr 8794 cv = append(cv, col) 8795 8796 } 8797 *v = cv 8798 return nil 8799} 8800 8801func awsAwsjson11_deserializeDocumentOutputVariablesMap(v *map[string]string, value interface{}) error { 8802 if v == nil { 8803 return fmt.Errorf("unexpected nil of type %T", v) 8804 } 8805 if value == nil { 8806 return nil 8807 } 8808 8809 shape, ok := value.(map[string]interface{}) 8810 if !ok { 8811 return fmt.Errorf("unexpected JSON type %v", value) 8812 } 8813 8814 var mv map[string]string 8815 if *v == nil { 8816 mv = map[string]string{} 8817 } else { 8818 mv = *v 8819 } 8820 8821 for key, value := range shape { 8822 var parsedVal string 8823 if value != nil { 8824 jtv, ok := value.(string) 8825 if !ok { 8826 return fmt.Errorf("expected OutputVariablesValue to be of type string, got %T instead", value) 8827 } 8828 parsedVal = jtv 8829 } 8830 mv[key] = parsedVal 8831 8832 } 8833 *v = mv 8834 return nil 8835} 8836 8837func awsAwsjson11_deserializeDocumentOutputVariablesSizeExceededException(v **types.OutputVariablesSizeExceededException, value interface{}) error { 8838 if v == nil { 8839 return fmt.Errorf("unexpected nil of type %T", v) 8840 } 8841 if value == nil { 8842 return nil 8843 } 8844 8845 shape, ok := value.(map[string]interface{}) 8846 if !ok { 8847 return fmt.Errorf("unexpected JSON type %v", value) 8848 } 8849 8850 var sv *types.OutputVariablesSizeExceededException 8851 if *v == nil { 8852 sv = &types.OutputVariablesSizeExceededException{} 8853 } else { 8854 sv = *v 8855 } 8856 8857 for key, value := range shape { 8858 switch key { 8859 case "message": 8860 if value != nil { 8861 jtv, ok := value.(string) 8862 if !ok { 8863 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 8864 } 8865 sv.Message = ptr.String(jtv) 8866 } 8867 8868 default: 8869 _, _ = key, value 8870 8871 } 8872 } 8873 *v = sv 8874 return nil 8875} 8876 8877func awsAwsjson11_deserializeDocumentPipelineContext(v **types.PipelineContext, value interface{}) error { 8878 if v == nil { 8879 return fmt.Errorf("unexpected nil of type %T", v) 8880 } 8881 if value == nil { 8882 return nil 8883 } 8884 8885 shape, ok := value.(map[string]interface{}) 8886 if !ok { 8887 return fmt.Errorf("unexpected JSON type %v", value) 8888 } 8889 8890 var sv *types.PipelineContext 8891 if *v == nil { 8892 sv = &types.PipelineContext{} 8893 } else { 8894 sv = *v 8895 } 8896 8897 for key, value := range shape { 8898 switch key { 8899 case "action": 8900 if err := awsAwsjson11_deserializeDocumentActionContext(&sv.Action, value); err != nil { 8901 return err 8902 } 8903 8904 case "pipelineArn": 8905 if value != nil { 8906 jtv, ok := value.(string) 8907 if !ok { 8908 return fmt.Errorf("expected PipelineArn to be of type string, got %T instead", value) 8909 } 8910 sv.PipelineArn = ptr.String(jtv) 8911 } 8912 8913 case "pipelineExecutionId": 8914 if value != nil { 8915 jtv, ok := value.(string) 8916 if !ok { 8917 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 8918 } 8919 sv.PipelineExecutionId = ptr.String(jtv) 8920 } 8921 8922 case "pipelineName": 8923 if value != nil { 8924 jtv, ok := value.(string) 8925 if !ok { 8926 return fmt.Errorf("expected PipelineName to be of type string, got %T instead", value) 8927 } 8928 sv.PipelineName = ptr.String(jtv) 8929 } 8930 8931 case "stage": 8932 if err := awsAwsjson11_deserializeDocumentStageContext(&sv.Stage, value); err != nil { 8933 return err 8934 } 8935 8936 default: 8937 _, _ = key, value 8938 8939 } 8940 } 8941 *v = sv 8942 return nil 8943} 8944 8945func awsAwsjson11_deserializeDocumentPipelineDeclaration(v **types.PipelineDeclaration, value interface{}) error { 8946 if v == nil { 8947 return fmt.Errorf("unexpected nil of type %T", v) 8948 } 8949 if value == nil { 8950 return nil 8951 } 8952 8953 shape, ok := value.(map[string]interface{}) 8954 if !ok { 8955 return fmt.Errorf("unexpected JSON type %v", value) 8956 } 8957 8958 var sv *types.PipelineDeclaration 8959 if *v == nil { 8960 sv = &types.PipelineDeclaration{} 8961 } else { 8962 sv = *v 8963 } 8964 8965 for key, value := range shape { 8966 switch key { 8967 case "artifactStore": 8968 if err := awsAwsjson11_deserializeDocumentArtifactStore(&sv.ArtifactStore, value); err != nil { 8969 return err 8970 } 8971 8972 case "artifactStores": 8973 if err := awsAwsjson11_deserializeDocumentArtifactStoreMap(&sv.ArtifactStores, value); err != nil { 8974 return err 8975 } 8976 8977 case "name": 8978 if value != nil { 8979 jtv, ok := value.(string) 8980 if !ok { 8981 return fmt.Errorf("expected PipelineName to be of type string, got %T instead", value) 8982 } 8983 sv.Name = ptr.String(jtv) 8984 } 8985 8986 case "roleArn": 8987 if value != nil { 8988 jtv, ok := value.(string) 8989 if !ok { 8990 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 8991 } 8992 sv.RoleArn = ptr.String(jtv) 8993 } 8994 8995 case "stages": 8996 if err := awsAwsjson11_deserializeDocumentPipelineStageDeclarationList(&sv.Stages, value); err != nil { 8997 return err 8998 } 8999 9000 case "version": 9001 if value != nil { 9002 jtv, ok := value.(json.Number) 9003 if !ok { 9004 return fmt.Errorf("expected PipelineVersion to be json.Number, got %T instead", value) 9005 } 9006 i64, err := jtv.Int64() 9007 if err != nil { 9008 return err 9009 } 9010 sv.Version = ptr.Int32(int32(i64)) 9011 } 9012 9013 default: 9014 _, _ = key, value 9015 9016 } 9017 } 9018 *v = sv 9019 return nil 9020} 9021 9022func awsAwsjson11_deserializeDocumentPipelineExecution(v **types.PipelineExecution, value interface{}) error { 9023 if v == nil { 9024 return fmt.Errorf("unexpected nil of type %T", v) 9025 } 9026 if value == nil { 9027 return nil 9028 } 9029 9030 shape, ok := value.(map[string]interface{}) 9031 if !ok { 9032 return fmt.Errorf("unexpected JSON type %v", value) 9033 } 9034 9035 var sv *types.PipelineExecution 9036 if *v == nil { 9037 sv = &types.PipelineExecution{} 9038 } else { 9039 sv = *v 9040 } 9041 9042 for key, value := range shape { 9043 switch key { 9044 case "artifactRevisions": 9045 if err := awsAwsjson11_deserializeDocumentArtifactRevisionList(&sv.ArtifactRevisions, value); err != nil { 9046 return err 9047 } 9048 9049 case "pipelineExecutionId": 9050 if value != nil { 9051 jtv, ok := value.(string) 9052 if !ok { 9053 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 9054 } 9055 sv.PipelineExecutionId = ptr.String(jtv) 9056 } 9057 9058 case "pipelineName": 9059 if value != nil { 9060 jtv, ok := value.(string) 9061 if !ok { 9062 return fmt.Errorf("expected PipelineName to be of type string, got %T instead", value) 9063 } 9064 sv.PipelineName = ptr.String(jtv) 9065 } 9066 9067 case "pipelineVersion": 9068 if value != nil { 9069 jtv, ok := value.(json.Number) 9070 if !ok { 9071 return fmt.Errorf("expected PipelineVersion to be json.Number, got %T instead", value) 9072 } 9073 i64, err := jtv.Int64() 9074 if err != nil { 9075 return err 9076 } 9077 sv.PipelineVersion = ptr.Int32(int32(i64)) 9078 } 9079 9080 case "status": 9081 if value != nil { 9082 jtv, ok := value.(string) 9083 if !ok { 9084 return fmt.Errorf("expected PipelineExecutionStatus to be of type string, got %T instead", value) 9085 } 9086 sv.Status = types.PipelineExecutionStatus(jtv) 9087 } 9088 9089 default: 9090 _, _ = key, value 9091 9092 } 9093 } 9094 *v = sv 9095 return nil 9096} 9097 9098func awsAwsjson11_deserializeDocumentPipelineExecutionNotFoundException(v **types.PipelineExecutionNotFoundException, value interface{}) error { 9099 if v == nil { 9100 return fmt.Errorf("unexpected nil of type %T", v) 9101 } 9102 if value == nil { 9103 return nil 9104 } 9105 9106 shape, ok := value.(map[string]interface{}) 9107 if !ok { 9108 return fmt.Errorf("unexpected JSON type %v", value) 9109 } 9110 9111 var sv *types.PipelineExecutionNotFoundException 9112 if *v == nil { 9113 sv = &types.PipelineExecutionNotFoundException{} 9114 } else { 9115 sv = *v 9116 } 9117 9118 for key, value := range shape { 9119 switch key { 9120 case "message": 9121 if value != nil { 9122 jtv, ok := value.(string) 9123 if !ok { 9124 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9125 } 9126 sv.Message = ptr.String(jtv) 9127 } 9128 9129 default: 9130 _, _ = key, value 9131 9132 } 9133 } 9134 *v = sv 9135 return nil 9136} 9137 9138func awsAwsjson11_deserializeDocumentPipelineExecutionNotStoppableException(v **types.PipelineExecutionNotStoppableException, value interface{}) error { 9139 if v == nil { 9140 return fmt.Errorf("unexpected nil of type %T", v) 9141 } 9142 if value == nil { 9143 return nil 9144 } 9145 9146 shape, ok := value.(map[string]interface{}) 9147 if !ok { 9148 return fmt.Errorf("unexpected JSON type %v", value) 9149 } 9150 9151 var sv *types.PipelineExecutionNotStoppableException 9152 if *v == nil { 9153 sv = &types.PipelineExecutionNotStoppableException{} 9154 } else { 9155 sv = *v 9156 } 9157 9158 for key, value := range shape { 9159 switch key { 9160 case "message": 9161 if value != nil { 9162 jtv, ok := value.(string) 9163 if !ok { 9164 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9165 } 9166 sv.Message = ptr.String(jtv) 9167 } 9168 9169 default: 9170 _, _ = key, value 9171 9172 } 9173 } 9174 *v = sv 9175 return nil 9176} 9177 9178func awsAwsjson11_deserializeDocumentPipelineExecutionSummary(v **types.PipelineExecutionSummary, value interface{}) error { 9179 if v == nil { 9180 return fmt.Errorf("unexpected nil of type %T", v) 9181 } 9182 if value == nil { 9183 return nil 9184 } 9185 9186 shape, ok := value.(map[string]interface{}) 9187 if !ok { 9188 return fmt.Errorf("unexpected JSON type %v", value) 9189 } 9190 9191 var sv *types.PipelineExecutionSummary 9192 if *v == nil { 9193 sv = &types.PipelineExecutionSummary{} 9194 } else { 9195 sv = *v 9196 } 9197 9198 for key, value := range shape { 9199 switch key { 9200 case "lastUpdateTime": 9201 if value != nil { 9202 jtv, ok := value.(json.Number) 9203 if !ok { 9204 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9205 } 9206 f64, err := jtv.Float64() 9207 if err != nil { 9208 return err 9209 } 9210 sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9211 } 9212 9213 case "pipelineExecutionId": 9214 if value != nil { 9215 jtv, ok := value.(string) 9216 if !ok { 9217 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 9218 } 9219 sv.PipelineExecutionId = ptr.String(jtv) 9220 } 9221 9222 case "sourceRevisions": 9223 if err := awsAwsjson11_deserializeDocumentSourceRevisionList(&sv.SourceRevisions, value); err != nil { 9224 return err 9225 } 9226 9227 case "startTime": 9228 if value != nil { 9229 jtv, ok := value.(json.Number) 9230 if !ok { 9231 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9232 } 9233 f64, err := jtv.Float64() 9234 if err != nil { 9235 return err 9236 } 9237 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9238 } 9239 9240 case "status": 9241 if value != nil { 9242 jtv, ok := value.(string) 9243 if !ok { 9244 return fmt.Errorf("expected PipelineExecutionStatus to be of type string, got %T instead", value) 9245 } 9246 sv.Status = types.PipelineExecutionStatus(jtv) 9247 } 9248 9249 case "stopTrigger": 9250 if err := awsAwsjson11_deserializeDocumentStopExecutionTrigger(&sv.StopTrigger, value); err != nil { 9251 return err 9252 } 9253 9254 case "trigger": 9255 if err := awsAwsjson11_deserializeDocumentExecutionTrigger(&sv.Trigger, value); err != nil { 9256 return err 9257 } 9258 9259 default: 9260 _, _ = key, value 9261 9262 } 9263 } 9264 *v = sv 9265 return nil 9266} 9267 9268func awsAwsjson11_deserializeDocumentPipelineExecutionSummaryList(v *[]types.PipelineExecutionSummary, value interface{}) error { 9269 if v == nil { 9270 return fmt.Errorf("unexpected nil of type %T", v) 9271 } 9272 if value == nil { 9273 return nil 9274 } 9275 9276 shape, ok := value.([]interface{}) 9277 if !ok { 9278 return fmt.Errorf("unexpected JSON type %v", value) 9279 } 9280 9281 var cv []types.PipelineExecutionSummary 9282 if *v == nil { 9283 cv = []types.PipelineExecutionSummary{} 9284 } else { 9285 cv = *v 9286 } 9287 9288 for _, value := range shape { 9289 var col types.PipelineExecutionSummary 9290 destAddr := &col 9291 if err := awsAwsjson11_deserializeDocumentPipelineExecutionSummary(&destAddr, value); err != nil { 9292 return err 9293 } 9294 col = *destAddr 9295 cv = append(cv, col) 9296 9297 } 9298 *v = cv 9299 return nil 9300} 9301 9302func awsAwsjson11_deserializeDocumentPipelineList(v *[]types.PipelineSummary, value interface{}) error { 9303 if v == nil { 9304 return fmt.Errorf("unexpected nil of type %T", v) 9305 } 9306 if value == nil { 9307 return nil 9308 } 9309 9310 shape, ok := value.([]interface{}) 9311 if !ok { 9312 return fmt.Errorf("unexpected JSON type %v", value) 9313 } 9314 9315 var cv []types.PipelineSummary 9316 if *v == nil { 9317 cv = []types.PipelineSummary{} 9318 } else { 9319 cv = *v 9320 } 9321 9322 for _, value := range shape { 9323 var col types.PipelineSummary 9324 destAddr := &col 9325 if err := awsAwsjson11_deserializeDocumentPipelineSummary(&destAddr, value); err != nil { 9326 return err 9327 } 9328 col = *destAddr 9329 cv = append(cv, col) 9330 9331 } 9332 *v = cv 9333 return nil 9334} 9335 9336func awsAwsjson11_deserializeDocumentPipelineMetadata(v **types.PipelineMetadata, value interface{}) error { 9337 if v == nil { 9338 return fmt.Errorf("unexpected nil of type %T", v) 9339 } 9340 if value == nil { 9341 return nil 9342 } 9343 9344 shape, ok := value.(map[string]interface{}) 9345 if !ok { 9346 return fmt.Errorf("unexpected JSON type %v", value) 9347 } 9348 9349 var sv *types.PipelineMetadata 9350 if *v == nil { 9351 sv = &types.PipelineMetadata{} 9352 } else { 9353 sv = *v 9354 } 9355 9356 for key, value := range shape { 9357 switch key { 9358 case "created": 9359 if value != nil { 9360 jtv, ok := value.(json.Number) 9361 if !ok { 9362 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9363 } 9364 f64, err := jtv.Float64() 9365 if err != nil { 9366 return err 9367 } 9368 sv.Created = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9369 } 9370 9371 case "pipelineArn": 9372 if value != nil { 9373 jtv, ok := value.(string) 9374 if !ok { 9375 return fmt.Errorf("expected PipelineArn to be of type string, got %T instead", value) 9376 } 9377 sv.PipelineArn = ptr.String(jtv) 9378 } 9379 9380 case "updated": 9381 if value != nil { 9382 jtv, ok := value.(json.Number) 9383 if !ok { 9384 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9385 } 9386 f64, err := jtv.Float64() 9387 if err != nil { 9388 return err 9389 } 9390 sv.Updated = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9391 } 9392 9393 default: 9394 _, _ = key, value 9395 9396 } 9397 } 9398 *v = sv 9399 return nil 9400} 9401 9402func awsAwsjson11_deserializeDocumentPipelineNameInUseException(v **types.PipelineNameInUseException, value interface{}) error { 9403 if v == nil { 9404 return fmt.Errorf("unexpected nil of type %T", v) 9405 } 9406 if value == nil { 9407 return nil 9408 } 9409 9410 shape, ok := value.(map[string]interface{}) 9411 if !ok { 9412 return fmt.Errorf("unexpected JSON type %v", value) 9413 } 9414 9415 var sv *types.PipelineNameInUseException 9416 if *v == nil { 9417 sv = &types.PipelineNameInUseException{} 9418 } else { 9419 sv = *v 9420 } 9421 9422 for key, value := range shape { 9423 switch key { 9424 case "message": 9425 if value != nil { 9426 jtv, ok := value.(string) 9427 if !ok { 9428 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9429 } 9430 sv.Message = ptr.String(jtv) 9431 } 9432 9433 default: 9434 _, _ = key, value 9435 9436 } 9437 } 9438 *v = sv 9439 return nil 9440} 9441 9442func awsAwsjson11_deserializeDocumentPipelineNotFoundException(v **types.PipelineNotFoundException, value interface{}) error { 9443 if v == nil { 9444 return fmt.Errorf("unexpected nil of type %T", v) 9445 } 9446 if value == nil { 9447 return nil 9448 } 9449 9450 shape, ok := value.(map[string]interface{}) 9451 if !ok { 9452 return fmt.Errorf("unexpected JSON type %v", value) 9453 } 9454 9455 var sv *types.PipelineNotFoundException 9456 if *v == nil { 9457 sv = &types.PipelineNotFoundException{} 9458 } else { 9459 sv = *v 9460 } 9461 9462 for key, value := range shape { 9463 switch key { 9464 case "message": 9465 if value != nil { 9466 jtv, ok := value.(string) 9467 if !ok { 9468 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9469 } 9470 sv.Message = ptr.String(jtv) 9471 } 9472 9473 default: 9474 _, _ = key, value 9475 9476 } 9477 } 9478 *v = sv 9479 return nil 9480} 9481 9482func awsAwsjson11_deserializeDocumentPipelineStageDeclarationList(v *[]types.StageDeclaration, value interface{}) error { 9483 if v == nil { 9484 return fmt.Errorf("unexpected nil of type %T", v) 9485 } 9486 if value == nil { 9487 return nil 9488 } 9489 9490 shape, ok := value.([]interface{}) 9491 if !ok { 9492 return fmt.Errorf("unexpected JSON type %v", value) 9493 } 9494 9495 var cv []types.StageDeclaration 9496 if *v == nil { 9497 cv = []types.StageDeclaration{} 9498 } else { 9499 cv = *v 9500 } 9501 9502 for _, value := range shape { 9503 var col types.StageDeclaration 9504 destAddr := &col 9505 if err := awsAwsjson11_deserializeDocumentStageDeclaration(&destAddr, value); err != nil { 9506 return err 9507 } 9508 col = *destAddr 9509 cv = append(cv, col) 9510 9511 } 9512 *v = cv 9513 return nil 9514} 9515 9516func awsAwsjson11_deserializeDocumentPipelineSummary(v **types.PipelineSummary, value interface{}) error { 9517 if v == nil { 9518 return fmt.Errorf("unexpected nil of type %T", v) 9519 } 9520 if value == nil { 9521 return nil 9522 } 9523 9524 shape, ok := value.(map[string]interface{}) 9525 if !ok { 9526 return fmt.Errorf("unexpected JSON type %v", value) 9527 } 9528 9529 var sv *types.PipelineSummary 9530 if *v == nil { 9531 sv = &types.PipelineSummary{} 9532 } else { 9533 sv = *v 9534 } 9535 9536 for key, value := range shape { 9537 switch key { 9538 case "created": 9539 if value != nil { 9540 jtv, ok := value.(json.Number) 9541 if !ok { 9542 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9543 } 9544 f64, err := jtv.Float64() 9545 if err != nil { 9546 return err 9547 } 9548 sv.Created = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9549 } 9550 9551 case "name": 9552 if value != nil { 9553 jtv, ok := value.(string) 9554 if !ok { 9555 return fmt.Errorf("expected PipelineName to be of type string, got %T instead", value) 9556 } 9557 sv.Name = ptr.String(jtv) 9558 } 9559 9560 case "updated": 9561 if value != nil { 9562 jtv, ok := value.(json.Number) 9563 if !ok { 9564 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9565 } 9566 f64, err := jtv.Float64() 9567 if err != nil { 9568 return err 9569 } 9570 sv.Updated = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9571 } 9572 9573 case "version": 9574 if value != nil { 9575 jtv, ok := value.(json.Number) 9576 if !ok { 9577 return fmt.Errorf("expected PipelineVersion to be json.Number, got %T instead", value) 9578 } 9579 i64, err := jtv.Int64() 9580 if err != nil { 9581 return err 9582 } 9583 sv.Version = ptr.Int32(int32(i64)) 9584 } 9585 9586 default: 9587 _, _ = key, value 9588 9589 } 9590 } 9591 *v = sv 9592 return nil 9593} 9594 9595func awsAwsjson11_deserializeDocumentPipelineVersionNotFoundException(v **types.PipelineVersionNotFoundException, value interface{}) error { 9596 if v == nil { 9597 return fmt.Errorf("unexpected nil of type %T", v) 9598 } 9599 if value == nil { 9600 return nil 9601 } 9602 9603 shape, ok := value.(map[string]interface{}) 9604 if !ok { 9605 return fmt.Errorf("unexpected JSON type %v", value) 9606 } 9607 9608 var sv *types.PipelineVersionNotFoundException 9609 if *v == nil { 9610 sv = &types.PipelineVersionNotFoundException{} 9611 } else { 9612 sv = *v 9613 } 9614 9615 for key, value := range shape { 9616 switch key { 9617 case "message": 9618 if value != nil { 9619 jtv, ok := value.(string) 9620 if !ok { 9621 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9622 } 9623 sv.Message = ptr.String(jtv) 9624 } 9625 9626 default: 9627 _, _ = key, value 9628 9629 } 9630 } 9631 *v = sv 9632 return nil 9633} 9634 9635func awsAwsjson11_deserializeDocumentResolvedActionConfigurationMap(v *map[string]string, value interface{}) error { 9636 if v == nil { 9637 return fmt.Errorf("unexpected nil of type %T", v) 9638 } 9639 if value == nil { 9640 return nil 9641 } 9642 9643 shape, ok := value.(map[string]interface{}) 9644 if !ok { 9645 return fmt.Errorf("unexpected JSON type %v", value) 9646 } 9647 9648 var mv map[string]string 9649 if *v == nil { 9650 mv = map[string]string{} 9651 } else { 9652 mv = *v 9653 } 9654 9655 for key, value := range shape { 9656 var parsedVal string 9657 if value != nil { 9658 jtv, ok := value.(string) 9659 if !ok { 9660 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9661 } 9662 parsedVal = jtv 9663 } 9664 mv[key] = parsedVal 9665 9666 } 9667 *v = mv 9668 return nil 9669} 9670 9671func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 9672 if v == nil { 9673 return fmt.Errorf("unexpected nil of type %T", v) 9674 } 9675 if value == nil { 9676 return nil 9677 } 9678 9679 shape, ok := value.(map[string]interface{}) 9680 if !ok { 9681 return fmt.Errorf("unexpected JSON type %v", value) 9682 } 9683 9684 var sv *types.ResourceNotFoundException 9685 if *v == nil { 9686 sv = &types.ResourceNotFoundException{} 9687 } else { 9688 sv = *v 9689 } 9690 9691 for key, value := range shape { 9692 switch key { 9693 case "message": 9694 if value != nil { 9695 jtv, ok := value.(string) 9696 if !ok { 9697 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 9698 } 9699 sv.Message = ptr.String(jtv) 9700 } 9701 9702 default: 9703 _, _ = key, value 9704 9705 } 9706 } 9707 *v = sv 9708 return nil 9709} 9710 9711func awsAwsjson11_deserializeDocumentS3ArtifactLocation(v **types.S3ArtifactLocation, value interface{}) error { 9712 if v == nil { 9713 return fmt.Errorf("unexpected nil of type %T", v) 9714 } 9715 if value == nil { 9716 return nil 9717 } 9718 9719 shape, ok := value.(map[string]interface{}) 9720 if !ok { 9721 return fmt.Errorf("unexpected JSON type %v", value) 9722 } 9723 9724 var sv *types.S3ArtifactLocation 9725 if *v == nil { 9726 sv = &types.S3ArtifactLocation{} 9727 } else { 9728 sv = *v 9729 } 9730 9731 for key, value := range shape { 9732 switch key { 9733 case "bucketName": 9734 if value != nil { 9735 jtv, ok := value.(string) 9736 if !ok { 9737 return fmt.Errorf("expected S3BucketName to be of type string, got %T instead", value) 9738 } 9739 sv.BucketName = ptr.String(jtv) 9740 } 9741 9742 case "objectKey": 9743 if value != nil { 9744 jtv, ok := value.(string) 9745 if !ok { 9746 return fmt.Errorf("expected S3ObjectKey to be of type string, got %T instead", value) 9747 } 9748 sv.ObjectKey = ptr.String(jtv) 9749 } 9750 9751 default: 9752 _, _ = key, value 9753 9754 } 9755 } 9756 *v = sv 9757 return nil 9758} 9759 9760func awsAwsjson11_deserializeDocumentS3Location(v **types.S3Location, value interface{}) error { 9761 if v == nil { 9762 return fmt.Errorf("unexpected nil of type %T", v) 9763 } 9764 if value == nil { 9765 return nil 9766 } 9767 9768 shape, ok := value.(map[string]interface{}) 9769 if !ok { 9770 return fmt.Errorf("unexpected JSON type %v", value) 9771 } 9772 9773 var sv *types.S3Location 9774 if *v == nil { 9775 sv = &types.S3Location{} 9776 } else { 9777 sv = *v 9778 } 9779 9780 for key, value := range shape { 9781 switch key { 9782 case "bucket": 9783 if value != nil { 9784 jtv, ok := value.(string) 9785 if !ok { 9786 return fmt.Errorf("expected S3Bucket to be of type string, got %T instead", value) 9787 } 9788 sv.Bucket = ptr.String(jtv) 9789 } 9790 9791 case "key": 9792 if value != nil { 9793 jtv, ok := value.(string) 9794 if !ok { 9795 return fmt.Errorf("expected S3Key to be of type string, got %T instead", value) 9796 } 9797 sv.Key = ptr.String(jtv) 9798 } 9799 9800 default: 9801 _, _ = key, value 9802 9803 } 9804 } 9805 *v = sv 9806 return nil 9807} 9808 9809func awsAwsjson11_deserializeDocumentSourceRevision(v **types.SourceRevision, value interface{}) error { 9810 if v == nil { 9811 return fmt.Errorf("unexpected nil of type %T", v) 9812 } 9813 if value == nil { 9814 return nil 9815 } 9816 9817 shape, ok := value.(map[string]interface{}) 9818 if !ok { 9819 return fmt.Errorf("unexpected JSON type %v", value) 9820 } 9821 9822 var sv *types.SourceRevision 9823 if *v == nil { 9824 sv = &types.SourceRevision{} 9825 } else { 9826 sv = *v 9827 } 9828 9829 for key, value := range shape { 9830 switch key { 9831 case "actionName": 9832 if value != nil { 9833 jtv, ok := value.(string) 9834 if !ok { 9835 return fmt.Errorf("expected ActionName to be of type string, got %T instead", value) 9836 } 9837 sv.ActionName = ptr.String(jtv) 9838 } 9839 9840 case "revisionId": 9841 if value != nil { 9842 jtv, ok := value.(string) 9843 if !ok { 9844 return fmt.Errorf("expected Revision to be of type string, got %T instead", value) 9845 } 9846 sv.RevisionId = ptr.String(jtv) 9847 } 9848 9849 case "revisionSummary": 9850 if value != nil { 9851 jtv, ok := value.(string) 9852 if !ok { 9853 return fmt.Errorf("expected RevisionSummary to be of type string, got %T instead", value) 9854 } 9855 sv.RevisionSummary = ptr.String(jtv) 9856 } 9857 9858 case "revisionUrl": 9859 if value != nil { 9860 jtv, ok := value.(string) 9861 if !ok { 9862 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 9863 } 9864 sv.RevisionUrl = ptr.String(jtv) 9865 } 9866 9867 default: 9868 _, _ = key, value 9869 9870 } 9871 } 9872 *v = sv 9873 return nil 9874} 9875 9876func awsAwsjson11_deserializeDocumentSourceRevisionList(v *[]types.SourceRevision, value interface{}) error { 9877 if v == nil { 9878 return fmt.Errorf("unexpected nil of type %T", v) 9879 } 9880 if value == nil { 9881 return nil 9882 } 9883 9884 shape, ok := value.([]interface{}) 9885 if !ok { 9886 return fmt.Errorf("unexpected JSON type %v", value) 9887 } 9888 9889 var cv []types.SourceRevision 9890 if *v == nil { 9891 cv = []types.SourceRevision{} 9892 } else { 9893 cv = *v 9894 } 9895 9896 for _, value := range shape { 9897 var col types.SourceRevision 9898 destAddr := &col 9899 if err := awsAwsjson11_deserializeDocumentSourceRevision(&destAddr, value); err != nil { 9900 return err 9901 } 9902 col = *destAddr 9903 cv = append(cv, col) 9904 9905 } 9906 *v = cv 9907 return nil 9908} 9909 9910func awsAwsjson11_deserializeDocumentStageActionDeclarationList(v *[]types.ActionDeclaration, value interface{}) error { 9911 if v == nil { 9912 return fmt.Errorf("unexpected nil of type %T", v) 9913 } 9914 if value == nil { 9915 return nil 9916 } 9917 9918 shape, ok := value.([]interface{}) 9919 if !ok { 9920 return fmt.Errorf("unexpected JSON type %v", value) 9921 } 9922 9923 var cv []types.ActionDeclaration 9924 if *v == nil { 9925 cv = []types.ActionDeclaration{} 9926 } else { 9927 cv = *v 9928 } 9929 9930 for _, value := range shape { 9931 var col types.ActionDeclaration 9932 destAddr := &col 9933 if err := awsAwsjson11_deserializeDocumentActionDeclaration(&destAddr, value); err != nil { 9934 return err 9935 } 9936 col = *destAddr 9937 cv = append(cv, col) 9938 9939 } 9940 *v = cv 9941 return nil 9942} 9943 9944func awsAwsjson11_deserializeDocumentStageBlockerDeclarationList(v *[]types.BlockerDeclaration, value interface{}) error { 9945 if v == nil { 9946 return fmt.Errorf("unexpected nil of type %T", v) 9947 } 9948 if value == nil { 9949 return nil 9950 } 9951 9952 shape, ok := value.([]interface{}) 9953 if !ok { 9954 return fmt.Errorf("unexpected JSON type %v", value) 9955 } 9956 9957 var cv []types.BlockerDeclaration 9958 if *v == nil { 9959 cv = []types.BlockerDeclaration{} 9960 } else { 9961 cv = *v 9962 } 9963 9964 for _, value := range shape { 9965 var col types.BlockerDeclaration 9966 destAddr := &col 9967 if err := awsAwsjson11_deserializeDocumentBlockerDeclaration(&destAddr, value); err != nil { 9968 return err 9969 } 9970 col = *destAddr 9971 cv = append(cv, col) 9972 9973 } 9974 *v = cv 9975 return nil 9976} 9977 9978func awsAwsjson11_deserializeDocumentStageContext(v **types.StageContext, value interface{}) error { 9979 if v == nil { 9980 return fmt.Errorf("unexpected nil of type %T", v) 9981 } 9982 if value == nil { 9983 return nil 9984 } 9985 9986 shape, ok := value.(map[string]interface{}) 9987 if !ok { 9988 return fmt.Errorf("unexpected JSON type %v", value) 9989 } 9990 9991 var sv *types.StageContext 9992 if *v == nil { 9993 sv = &types.StageContext{} 9994 } else { 9995 sv = *v 9996 } 9997 9998 for key, value := range shape { 9999 switch key { 10000 case "name": 10001 if value != nil { 10002 jtv, ok := value.(string) 10003 if !ok { 10004 return fmt.Errorf("expected StageName to be of type string, got %T instead", value) 10005 } 10006 sv.Name = ptr.String(jtv) 10007 } 10008 10009 default: 10010 _, _ = key, value 10011 10012 } 10013 } 10014 *v = sv 10015 return nil 10016} 10017 10018func awsAwsjson11_deserializeDocumentStageDeclaration(v **types.StageDeclaration, value interface{}) error { 10019 if v == nil { 10020 return fmt.Errorf("unexpected nil of type %T", v) 10021 } 10022 if value == nil { 10023 return nil 10024 } 10025 10026 shape, ok := value.(map[string]interface{}) 10027 if !ok { 10028 return fmt.Errorf("unexpected JSON type %v", value) 10029 } 10030 10031 var sv *types.StageDeclaration 10032 if *v == nil { 10033 sv = &types.StageDeclaration{} 10034 } else { 10035 sv = *v 10036 } 10037 10038 for key, value := range shape { 10039 switch key { 10040 case "actions": 10041 if err := awsAwsjson11_deserializeDocumentStageActionDeclarationList(&sv.Actions, value); err != nil { 10042 return err 10043 } 10044 10045 case "blockers": 10046 if err := awsAwsjson11_deserializeDocumentStageBlockerDeclarationList(&sv.Blockers, value); err != nil { 10047 return err 10048 } 10049 10050 case "name": 10051 if value != nil { 10052 jtv, ok := value.(string) 10053 if !ok { 10054 return fmt.Errorf("expected StageName to be of type string, got %T instead", value) 10055 } 10056 sv.Name = ptr.String(jtv) 10057 } 10058 10059 default: 10060 _, _ = key, value 10061 10062 } 10063 } 10064 *v = sv 10065 return nil 10066} 10067 10068func awsAwsjson11_deserializeDocumentStageExecution(v **types.StageExecution, value interface{}) error { 10069 if v == nil { 10070 return fmt.Errorf("unexpected nil of type %T", v) 10071 } 10072 if value == nil { 10073 return nil 10074 } 10075 10076 shape, ok := value.(map[string]interface{}) 10077 if !ok { 10078 return fmt.Errorf("unexpected JSON type %v", value) 10079 } 10080 10081 var sv *types.StageExecution 10082 if *v == nil { 10083 sv = &types.StageExecution{} 10084 } else { 10085 sv = *v 10086 } 10087 10088 for key, value := range shape { 10089 switch key { 10090 case "pipelineExecutionId": 10091 if value != nil { 10092 jtv, ok := value.(string) 10093 if !ok { 10094 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 10095 } 10096 sv.PipelineExecutionId = ptr.String(jtv) 10097 } 10098 10099 case "status": 10100 if value != nil { 10101 jtv, ok := value.(string) 10102 if !ok { 10103 return fmt.Errorf("expected StageExecutionStatus to be of type string, got %T instead", value) 10104 } 10105 sv.Status = types.StageExecutionStatus(jtv) 10106 } 10107 10108 default: 10109 _, _ = key, value 10110 10111 } 10112 } 10113 *v = sv 10114 return nil 10115} 10116 10117func awsAwsjson11_deserializeDocumentStageNotFoundException(v **types.StageNotFoundException, value interface{}) error { 10118 if v == nil { 10119 return fmt.Errorf("unexpected nil of type %T", v) 10120 } 10121 if value == nil { 10122 return nil 10123 } 10124 10125 shape, ok := value.(map[string]interface{}) 10126 if !ok { 10127 return fmt.Errorf("unexpected JSON type %v", value) 10128 } 10129 10130 var sv *types.StageNotFoundException 10131 if *v == nil { 10132 sv = &types.StageNotFoundException{} 10133 } else { 10134 sv = *v 10135 } 10136 10137 for key, value := range shape { 10138 switch key { 10139 case "message": 10140 if value != nil { 10141 jtv, ok := value.(string) 10142 if !ok { 10143 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 10144 } 10145 sv.Message = ptr.String(jtv) 10146 } 10147 10148 default: 10149 _, _ = key, value 10150 10151 } 10152 } 10153 *v = sv 10154 return nil 10155} 10156 10157func awsAwsjson11_deserializeDocumentStageNotRetryableException(v **types.StageNotRetryableException, value interface{}) error { 10158 if v == nil { 10159 return fmt.Errorf("unexpected nil of type %T", v) 10160 } 10161 if value == nil { 10162 return nil 10163 } 10164 10165 shape, ok := value.(map[string]interface{}) 10166 if !ok { 10167 return fmt.Errorf("unexpected JSON type %v", value) 10168 } 10169 10170 var sv *types.StageNotRetryableException 10171 if *v == nil { 10172 sv = &types.StageNotRetryableException{} 10173 } else { 10174 sv = *v 10175 } 10176 10177 for key, value := range shape { 10178 switch key { 10179 case "message": 10180 if value != nil { 10181 jtv, ok := value.(string) 10182 if !ok { 10183 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 10184 } 10185 sv.Message = ptr.String(jtv) 10186 } 10187 10188 default: 10189 _, _ = key, value 10190 10191 } 10192 } 10193 *v = sv 10194 return nil 10195} 10196 10197func awsAwsjson11_deserializeDocumentStageState(v **types.StageState, value interface{}) error { 10198 if v == nil { 10199 return fmt.Errorf("unexpected nil of type %T", v) 10200 } 10201 if value == nil { 10202 return nil 10203 } 10204 10205 shape, ok := value.(map[string]interface{}) 10206 if !ok { 10207 return fmt.Errorf("unexpected JSON type %v", value) 10208 } 10209 10210 var sv *types.StageState 10211 if *v == nil { 10212 sv = &types.StageState{} 10213 } else { 10214 sv = *v 10215 } 10216 10217 for key, value := range shape { 10218 switch key { 10219 case "actionStates": 10220 if err := awsAwsjson11_deserializeDocumentActionStateList(&sv.ActionStates, value); err != nil { 10221 return err 10222 } 10223 10224 case "inboundExecution": 10225 if err := awsAwsjson11_deserializeDocumentStageExecution(&sv.InboundExecution, value); err != nil { 10226 return err 10227 } 10228 10229 case "inboundTransitionState": 10230 if err := awsAwsjson11_deserializeDocumentTransitionState(&sv.InboundTransitionState, value); err != nil { 10231 return err 10232 } 10233 10234 case "latestExecution": 10235 if err := awsAwsjson11_deserializeDocumentStageExecution(&sv.LatestExecution, value); err != nil { 10236 return err 10237 } 10238 10239 case "stageName": 10240 if value != nil { 10241 jtv, ok := value.(string) 10242 if !ok { 10243 return fmt.Errorf("expected StageName to be of type string, got %T instead", value) 10244 } 10245 sv.StageName = ptr.String(jtv) 10246 } 10247 10248 default: 10249 _, _ = key, value 10250 10251 } 10252 } 10253 *v = sv 10254 return nil 10255} 10256 10257func awsAwsjson11_deserializeDocumentStageStateList(v *[]types.StageState, value interface{}) error { 10258 if v == nil { 10259 return fmt.Errorf("unexpected nil of type %T", v) 10260 } 10261 if value == nil { 10262 return nil 10263 } 10264 10265 shape, ok := value.([]interface{}) 10266 if !ok { 10267 return fmt.Errorf("unexpected JSON type %v", value) 10268 } 10269 10270 var cv []types.StageState 10271 if *v == nil { 10272 cv = []types.StageState{} 10273 } else { 10274 cv = *v 10275 } 10276 10277 for _, value := range shape { 10278 var col types.StageState 10279 destAddr := &col 10280 if err := awsAwsjson11_deserializeDocumentStageState(&destAddr, value); err != nil { 10281 return err 10282 } 10283 col = *destAddr 10284 cv = append(cv, col) 10285 10286 } 10287 *v = cv 10288 return nil 10289} 10290 10291func awsAwsjson11_deserializeDocumentStopExecutionTrigger(v **types.StopExecutionTrigger, value interface{}) error { 10292 if v == nil { 10293 return fmt.Errorf("unexpected nil of type %T", v) 10294 } 10295 if value == nil { 10296 return nil 10297 } 10298 10299 shape, ok := value.(map[string]interface{}) 10300 if !ok { 10301 return fmt.Errorf("unexpected JSON type %v", value) 10302 } 10303 10304 var sv *types.StopExecutionTrigger 10305 if *v == nil { 10306 sv = &types.StopExecutionTrigger{} 10307 } else { 10308 sv = *v 10309 } 10310 10311 for key, value := range shape { 10312 switch key { 10313 case "reason": 10314 if value != nil { 10315 jtv, ok := value.(string) 10316 if !ok { 10317 return fmt.Errorf("expected StopPipelineExecutionReason to be of type string, got %T instead", value) 10318 } 10319 sv.Reason = ptr.String(jtv) 10320 } 10321 10322 default: 10323 _, _ = key, value 10324 10325 } 10326 } 10327 *v = sv 10328 return nil 10329} 10330 10331func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 10332 if v == nil { 10333 return fmt.Errorf("unexpected nil of type %T", v) 10334 } 10335 if value == nil { 10336 return nil 10337 } 10338 10339 shape, ok := value.(map[string]interface{}) 10340 if !ok { 10341 return fmt.Errorf("unexpected JSON type %v", value) 10342 } 10343 10344 var sv *types.Tag 10345 if *v == nil { 10346 sv = &types.Tag{} 10347 } else { 10348 sv = *v 10349 } 10350 10351 for key, value := range shape { 10352 switch key { 10353 case "key": 10354 if value != nil { 10355 jtv, ok := value.(string) 10356 if !ok { 10357 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 10358 } 10359 sv.Key = ptr.String(jtv) 10360 } 10361 10362 case "value": 10363 if value != nil { 10364 jtv, ok := value.(string) 10365 if !ok { 10366 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 10367 } 10368 sv.Value = ptr.String(jtv) 10369 } 10370 10371 default: 10372 _, _ = key, value 10373 10374 } 10375 } 10376 *v = sv 10377 return nil 10378} 10379 10380func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error { 10381 if v == nil { 10382 return fmt.Errorf("unexpected nil of type %T", v) 10383 } 10384 if value == nil { 10385 return nil 10386 } 10387 10388 shape, ok := value.([]interface{}) 10389 if !ok { 10390 return fmt.Errorf("unexpected JSON type %v", value) 10391 } 10392 10393 var cv []types.Tag 10394 if *v == nil { 10395 cv = []types.Tag{} 10396 } else { 10397 cv = *v 10398 } 10399 10400 for _, value := range shape { 10401 var col types.Tag 10402 destAddr := &col 10403 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 10404 return err 10405 } 10406 col = *destAddr 10407 cv = append(cv, col) 10408 10409 } 10410 *v = cv 10411 return nil 10412} 10413 10414func awsAwsjson11_deserializeDocumentThirdPartyJob(v **types.ThirdPartyJob, value interface{}) error { 10415 if v == nil { 10416 return fmt.Errorf("unexpected nil of type %T", v) 10417 } 10418 if value == nil { 10419 return nil 10420 } 10421 10422 shape, ok := value.(map[string]interface{}) 10423 if !ok { 10424 return fmt.Errorf("unexpected JSON type %v", value) 10425 } 10426 10427 var sv *types.ThirdPartyJob 10428 if *v == nil { 10429 sv = &types.ThirdPartyJob{} 10430 } else { 10431 sv = *v 10432 } 10433 10434 for key, value := range shape { 10435 switch key { 10436 case "clientId": 10437 if value != nil { 10438 jtv, ok := value.(string) 10439 if !ok { 10440 return fmt.Errorf("expected ClientId to be of type string, got %T instead", value) 10441 } 10442 sv.ClientId = ptr.String(jtv) 10443 } 10444 10445 case "jobId": 10446 if value != nil { 10447 jtv, ok := value.(string) 10448 if !ok { 10449 return fmt.Errorf("expected JobId to be of type string, got %T instead", value) 10450 } 10451 sv.JobId = ptr.String(jtv) 10452 } 10453 10454 default: 10455 _, _ = key, value 10456 10457 } 10458 } 10459 *v = sv 10460 return nil 10461} 10462 10463func awsAwsjson11_deserializeDocumentThirdPartyJobData(v **types.ThirdPartyJobData, value interface{}) error { 10464 if v == nil { 10465 return fmt.Errorf("unexpected nil of type %T", v) 10466 } 10467 if value == nil { 10468 return nil 10469 } 10470 10471 shape, ok := value.(map[string]interface{}) 10472 if !ok { 10473 return fmt.Errorf("unexpected JSON type %v", value) 10474 } 10475 10476 var sv *types.ThirdPartyJobData 10477 if *v == nil { 10478 sv = &types.ThirdPartyJobData{} 10479 } else { 10480 sv = *v 10481 } 10482 10483 for key, value := range shape { 10484 switch key { 10485 case "actionConfiguration": 10486 if err := awsAwsjson11_deserializeDocumentActionConfiguration(&sv.ActionConfiguration, value); err != nil { 10487 return err 10488 } 10489 10490 case "actionTypeId": 10491 if err := awsAwsjson11_deserializeDocumentActionTypeId(&sv.ActionTypeId, value); err != nil { 10492 return err 10493 } 10494 10495 case "artifactCredentials": 10496 if err := awsAwsjson11_deserializeDocumentAWSSessionCredentials(&sv.ArtifactCredentials, value); err != nil { 10497 return err 10498 } 10499 10500 case "continuationToken": 10501 if value != nil { 10502 jtv, ok := value.(string) 10503 if !ok { 10504 return fmt.Errorf("expected ContinuationToken to be of type string, got %T instead", value) 10505 } 10506 sv.ContinuationToken = ptr.String(jtv) 10507 } 10508 10509 case "encryptionKey": 10510 if err := awsAwsjson11_deserializeDocumentEncryptionKey(&sv.EncryptionKey, value); err != nil { 10511 return err 10512 } 10513 10514 case "inputArtifacts": 10515 if err := awsAwsjson11_deserializeDocumentArtifactList(&sv.InputArtifacts, value); err != nil { 10516 return err 10517 } 10518 10519 case "outputArtifacts": 10520 if err := awsAwsjson11_deserializeDocumentArtifactList(&sv.OutputArtifacts, value); err != nil { 10521 return err 10522 } 10523 10524 case "pipelineContext": 10525 if err := awsAwsjson11_deserializeDocumentPipelineContext(&sv.PipelineContext, value); err != nil { 10526 return err 10527 } 10528 10529 default: 10530 _, _ = key, value 10531 10532 } 10533 } 10534 *v = sv 10535 return nil 10536} 10537 10538func awsAwsjson11_deserializeDocumentThirdPartyJobDetails(v **types.ThirdPartyJobDetails, value interface{}) error { 10539 if v == nil { 10540 return fmt.Errorf("unexpected nil of type %T", v) 10541 } 10542 if value == nil { 10543 return nil 10544 } 10545 10546 shape, ok := value.(map[string]interface{}) 10547 if !ok { 10548 return fmt.Errorf("unexpected JSON type %v", value) 10549 } 10550 10551 var sv *types.ThirdPartyJobDetails 10552 if *v == nil { 10553 sv = &types.ThirdPartyJobDetails{} 10554 } else { 10555 sv = *v 10556 } 10557 10558 for key, value := range shape { 10559 switch key { 10560 case "data": 10561 if err := awsAwsjson11_deserializeDocumentThirdPartyJobData(&sv.Data, value); err != nil { 10562 return err 10563 } 10564 10565 case "id": 10566 if value != nil { 10567 jtv, ok := value.(string) 10568 if !ok { 10569 return fmt.Errorf("expected ThirdPartyJobId to be of type string, got %T instead", value) 10570 } 10571 sv.Id = ptr.String(jtv) 10572 } 10573 10574 case "nonce": 10575 if value != nil { 10576 jtv, ok := value.(string) 10577 if !ok { 10578 return fmt.Errorf("expected Nonce to be of type string, got %T instead", value) 10579 } 10580 sv.Nonce = ptr.String(jtv) 10581 } 10582 10583 default: 10584 _, _ = key, value 10585 10586 } 10587 } 10588 *v = sv 10589 return nil 10590} 10591 10592func awsAwsjson11_deserializeDocumentThirdPartyJobList(v *[]types.ThirdPartyJob, value interface{}) error { 10593 if v == nil { 10594 return fmt.Errorf("unexpected nil of type %T", v) 10595 } 10596 if value == nil { 10597 return nil 10598 } 10599 10600 shape, ok := value.([]interface{}) 10601 if !ok { 10602 return fmt.Errorf("unexpected JSON type %v", value) 10603 } 10604 10605 var cv []types.ThirdPartyJob 10606 if *v == nil { 10607 cv = []types.ThirdPartyJob{} 10608 } else { 10609 cv = *v 10610 } 10611 10612 for _, value := range shape { 10613 var col types.ThirdPartyJob 10614 destAddr := &col 10615 if err := awsAwsjson11_deserializeDocumentThirdPartyJob(&destAddr, value); err != nil { 10616 return err 10617 } 10618 col = *destAddr 10619 cv = append(cv, col) 10620 10621 } 10622 *v = cv 10623 return nil 10624} 10625 10626func awsAwsjson11_deserializeDocumentTooManyTagsException(v **types.TooManyTagsException, value interface{}) error { 10627 if v == nil { 10628 return fmt.Errorf("unexpected nil of type %T", v) 10629 } 10630 if value == nil { 10631 return nil 10632 } 10633 10634 shape, ok := value.(map[string]interface{}) 10635 if !ok { 10636 return fmt.Errorf("unexpected JSON type %v", value) 10637 } 10638 10639 var sv *types.TooManyTagsException 10640 if *v == nil { 10641 sv = &types.TooManyTagsException{} 10642 } else { 10643 sv = *v 10644 } 10645 10646 for key, value := range shape { 10647 switch key { 10648 case "message": 10649 if value != nil { 10650 jtv, ok := value.(string) 10651 if !ok { 10652 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 10653 } 10654 sv.Message = ptr.String(jtv) 10655 } 10656 10657 default: 10658 _, _ = key, value 10659 10660 } 10661 } 10662 *v = sv 10663 return nil 10664} 10665 10666func awsAwsjson11_deserializeDocumentTransitionState(v **types.TransitionState, value interface{}) error { 10667 if v == nil { 10668 return fmt.Errorf("unexpected nil of type %T", v) 10669 } 10670 if value == nil { 10671 return nil 10672 } 10673 10674 shape, ok := value.(map[string]interface{}) 10675 if !ok { 10676 return fmt.Errorf("unexpected JSON type %v", value) 10677 } 10678 10679 var sv *types.TransitionState 10680 if *v == nil { 10681 sv = &types.TransitionState{} 10682 } else { 10683 sv = *v 10684 } 10685 10686 for key, value := range shape { 10687 switch key { 10688 case "disabledReason": 10689 if value != nil { 10690 jtv, ok := value.(string) 10691 if !ok { 10692 return fmt.Errorf("expected DisabledReason to be of type string, got %T instead", value) 10693 } 10694 sv.DisabledReason = ptr.String(jtv) 10695 } 10696 10697 case "enabled": 10698 if value != nil { 10699 jtv, ok := value.(bool) 10700 if !ok { 10701 return fmt.Errorf("expected Enabled to be of type *bool, got %T instead", value) 10702 } 10703 sv.Enabled = jtv 10704 } 10705 10706 case "lastChangedAt": 10707 if value != nil { 10708 jtv, ok := value.(json.Number) 10709 if !ok { 10710 return fmt.Errorf("expected LastChangedAt to be json.Number, got %T instead", value) 10711 } 10712 f64, err := jtv.Float64() 10713 if err != nil { 10714 return err 10715 } 10716 sv.LastChangedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10717 } 10718 10719 case "lastChangedBy": 10720 if value != nil { 10721 jtv, ok := value.(string) 10722 if !ok { 10723 return fmt.Errorf("expected LastChangedBy to be of type string, got %T instead", value) 10724 } 10725 sv.LastChangedBy = ptr.String(jtv) 10726 } 10727 10728 default: 10729 _, _ = key, value 10730 10731 } 10732 } 10733 *v = sv 10734 return nil 10735} 10736 10737func awsAwsjson11_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error { 10738 if v == nil { 10739 return fmt.Errorf("unexpected nil of type %T", v) 10740 } 10741 if value == nil { 10742 return nil 10743 } 10744 10745 shape, ok := value.(map[string]interface{}) 10746 if !ok { 10747 return fmt.Errorf("unexpected JSON type %v", value) 10748 } 10749 10750 var sv *types.ValidationException 10751 if *v == nil { 10752 sv = &types.ValidationException{} 10753 } else { 10754 sv = *v 10755 } 10756 10757 for key, value := range shape { 10758 switch key { 10759 case "message": 10760 if value != nil { 10761 jtv, ok := value.(string) 10762 if !ok { 10763 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 10764 } 10765 sv.Message = ptr.String(jtv) 10766 } 10767 10768 default: 10769 _, _ = key, value 10770 10771 } 10772 } 10773 *v = sv 10774 return nil 10775} 10776 10777func awsAwsjson11_deserializeDocumentWebhookAuthConfiguration(v **types.WebhookAuthConfiguration, value interface{}) error { 10778 if v == nil { 10779 return fmt.Errorf("unexpected nil of type %T", v) 10780 } 10781 if value == nil { 10782 return nil 10783 } 10784 10785 shape, ok := value.(map[string]interface{}) 10786 if !ok { 10787 return fmt.Errorf("unexpected JSON type %v", value) 10788 } 10789 10790 var sv *types.WebhookAuthConfiguration 10791 if *v == nil { 10792 sv = &types.WebhookAuthConfiguration{} 10793 } else { 10794 sv = *v 10795 } 10796 10797 for key, value := range shape { 10798 switch key { 10799 case "AllowedIPRange": 10800 if value != nil { 10801 jtv, ok := value.(string) 10802 if !ok { 10803 return fmt.Errorf("expected WebhookAuthConfigurationAllowedIPRange to be of type string, got %T instead", value) 10804 } 10805 sv.AllowedIPRange = ptr.String(jtv) 10806 } 10807 10808 case "SecretToken": 10809 if value != nil { 10810 jtv, ok := value.(string) 10811 if !ok { 10812 return fmt.Errorf("expected WebhookAuthConfigurationSecretToken to be of type string, got %T instead", value) 10813 } 10814 sv.SecretToken = ptr.String(jtv) 10815 } 10816 10817 default: 10818 _, _ = key, value 10819 10820 } 10821 } 10822 *v = sv 10823 return nil 10824} 10825 10826func awsAwsjson11_deserializeDocumentWebhookDefinition(v **types.WebhookDefinition, value interface{}) error { 10827 if v == nil { 10828 return fmt.Errorf("unexpected nil of type %T", v) 10829 } 10830 if value == nil { 10831 return nil 10832 } 10833 10834 shape, ok := value.(map[string]interface{}) 10835 if !ok { 10836 return fmt.Errorf("unexpected JSON type %v", value) 10837 } 10838 10839 var sv *types.WebhookDefinition 10840 if *v == nil { 10841 sv = &types.WebhookDefinition{} 10842 } else { 10843 sv = *v 10844 } 10845 10846 for key, value := range shape { 10847 switch key { 10848 case "authentication": 10849 if value != nil { 10850 jtv, ok := value.(string) 10851 if !ok { 10852 return fmt.Errorf("expected WebhookAuthenticationType to be of type string, got %T instead", value) 10853 } 10854 sv.Authentication = types.WebhookAuthenticationType(jtv) 10855 } 10856 10857 case "authenticationConfiguration": 10858 if err := awsAwsjson11_deserializeDocumentWebhookAuthConfiguration(&sv.AuthenticationConfiguration, value); err != nil { 10859 return err 10860 } 10861 10862 case "filters": 10863 if err := awsAwsjson11_deserializeDocumentWebhookFilters(&sv.Filters, value); err != nil { 10864 return err 10865 } 10866 10867 case "name": 10868 if value != nil { 10869 jtv, ok := value.(string) 10870 if !ok { 10871 return fmt.Errorf("expected WebhookName to be of type string, got %T instead", value) 10872 } 10873 sv.Name = ptr.String(jtv) 10874 } 10875 10876 case "targetAction": 10877 if value != nil { 10878 jtv, ok := value.(string) 10879 if !ok { 10880 return fmt.Errorf("expected ActionName to be of type string, got %T instead", value) 10881 } 10882 sv.TargetAction = ptr.String(jtv) 10883 } 10884 10885 case "targetPipeline": 10886 if value != nil { 10887 jtv, ok := value.(string) 10888 if !ok { 10889 return fmt.Errorf("expected PipelineName to be of type string, got %T instead", value) 10890 } 10891 sv.TargetPipeline = ptr.String(jtv) 10892 } 10893 10894 default: 10895 _, _ = key, value 10896 10897 } 10898 } 10899 *v = sv 10900 return nil 10901} 10902 10903func awsAwsjson11_deserializeDocumentWebhookFilterRule(v **types.WebhookFilterRule, value interface{}) error { 10904 if v == nil { 10905 return fmt.Errorf("unexpected nil of type %T", v) 10906 } 10907 if value == nil { 10908 return nil 10909 } 10910 10911 shape, ok := value.(map[string]interface{}) 10912 if !ok { 10913 return fmt.Errorf("unexpected JSON type %v", value) 10914 } 10915 10916 var sv *types.WebhookFilterRule 10917 if *v == nil { 10918 sv = &types.WebhookFilterRule{} 10919 } else { 10920 sv = *v 10921 } 10922 10923 for key, value := range shape { 10924 switch key { 10925 case "jsonPath": 10926 if value != nil { 10927 jtv, ok := value.(string) 10928 if !ok { 10929 return fmt.Errorf("expected JsonPath to be of type string, got %T instead", value) 10930 } 10931 sv.JsonPath = ptr.String(jtv) 10932 } 10933 10934 case "matchEquals": 10935 if value != nil { 10936 jtv, ok := value.(string) 10937 if !ok { 10938 return fmt.Errorf("expected MatchEquals to be of type string, got %T instead", value) 10939 } 10940 sv.MatchEquals = ptr.String(jtv) 10941 } 10942 10943 default: 10944 _, _ = key, value 10945 10946 } 10947 } 10948 *v = sv 10949 return nil 10950} 10951 10952func awsAwsjson11_deserializeDocumentWebhookFilters(v *[]types.WebhookFilterRule, value interface{}) error { 10953 if v == nil { 10954 return fmt.Errorf("unexpected nil of type %T", v) 10955 } 10956 if value == nil { 10957 return nil 10958 } 10959 10960 shape, ok := value.([]interface{}) 10961 if !ok { 10962 return fmt.Errorf("unexpected JSON type %v", value) 10963 } 10964 10965 var cv []types.WebhookFilterRule 10966 if *v == nil { 10967 cv = []types.WebhookFilterRule{} 10968 } else { 10969 cv = *v 10970 } 10971 10972 for _, value := range shape { 10973 var col types.WebhookFilterRule 10974 destAddr := &col 10975 if err := awsAwsjson11_deserializeDocumentWebhookFilterRule(&destAddr, value); err != nil { 10976 return err 10977 } 10978 col = *destAddr 10979 cv = append(cv, col) 10980 10981 } 10982 *v = cv 10983 return nil 10984} 10985 10986func awsAwsjson11_deserializeDocumentWebhookList(v *[]types.ListWebhookItem, value interface{}) error { 10987 if v == nil { 10988 return fmt.Errorf("unexpected nil of type %T", v) 10989 } 10990 if value == nil { 10991 return nil 10992 } 10993 10994 shape, ok := value.([]interface{}) 10995 if !ok { 10996 return fmt.Errorf("unexpected JSON type %v", value) 10997 } 10998 10999 var cv []types.ListWebhookItem 11000 if *v == nil { 11001 cv = []types.ListWebhookItem{} 11002 } else { 11003 cv = *v 11004 } 11005 11006 for _, value := range shape { 11007 var col types.ListWebhookItem 11008 destAddr := &col 11009 if err := awsAwsjson11_deserializeDocumentListWebhookItem(&destAddr, value); err != nil { 11010 return err 11011 } 11012 col = *destAddr 11013 cv = append(cv, col) 11014 11015 } 11016 *v = cv 11017 return nil 11018} 11019 11020func awsAwsjson11_deserializeDocumentWebhookNotFoundException(v **types.WebhookNotFoundException, value interface{}) error { 11021 if v == nil { 11022 return fmt.Errorf("unexpected nil of type %T", v) 11023 } 11024 if value == nil { 11025 return nil 11026 } 11027 11028 shape, ok := value.(map[string]interface{}) 11029 if !ok { 11030 return fmt.Errorf("unexpected JSON type %v", value) 11031 } 11032 11033 var sv *types.WebhookNotFoundException 11034 if *v == nil { 11035 sv = &types.WebhookNotFoundException{} 11036 } else { 11037 sv = *v 11038 } 11039 11040 for key, value := range shape { 11041 switch key { 11042 default: 11043 _, _ = key, value 11044 11045 } 11046 } 11047 *v = sv 11048 return nil 11049} 11050 11051func awsAwsjson11_deserializeOpDocumentAcknowledgeJobOutput(v **AcknowledgeJobOutput, value interface{}) error { 11052 if v == nil { 11053 return fmt.Errorf("unexpected nil of type %T", v) 11054 } 11055 if value == nil { 11056 return nil 11057 } 11058 11059 shape, ok := value.(map[string]interface{}) 11060 if !ok { 11061 return fmt.Errorf("unexpected JSON type %v", value) 11062 } 11063 11064 var sv *AcknowledgeJobOutput 11065 if *v == nil { 11066 sv = &AcknowledgeJobOutput{} 11067 } else { 11068 sv = *v 11069 } 11070 11071 for key, value := range shape { 11072 switch key { 11073 case "status": 11074 if value != nil { 11075 jtv, ok := value.(string) 11076 if !ok { 11077 return fmt.Errorf("expected JobStatus to be of type string, got %T instead", value) 11078 } 11079 sv.Status = types.JobStatus(jtv) 11080 } 11081 11082 default: 11083 _, _ = key, value 11084 11085 } 11086 } 11087 *v = sv 11088 return nil 11089} 11090 11091func awsAwsjson11_deserializeOpDocumentAcknowledgeThirdPartyJobOutput(v **AcknowledgeThirdPartyJobOutput, value interface{}) error { 11092 if v == nil { 11093 return fmt.Errorf("unexpected nil of type %T", v) 11094 } 11095 if value == nil { 11096 return nil 11097 } 11098 11099 shape, ok := value.(map[string]interface{}) 11100 if !ok { 11101 return fmt.Errorf("unexpected JSON type %v", value) 11102 } 11103 11104 var sv *AcknowledgeThirdPartyJobOutput 11105 if *v == nil { 11106 sv = &AcknowledgeThirdPartyJobOutput{} 11107 } else { 11108 sv = *v 11109 } 11110 11111 for key, value := range shape { 11112 switch key { 11113 case "status": 11114 if value != nil { 11115 jtv, ok := value.(string) 11116 if !ok { 11117 return fmt.Errorf("expected JobStatus to be of type string, got %T instead", value) 11118 } 11119 sv.Status = types.JobStatus(jtv) 11120 } 11121 11122 default: 11123 _, _ = key, value 11124 11125 } 11126 } 11127 *v = sv 11128 return nil 11129} 11130 11131func awsAwsjson11_deserializeOpDocumentCreateCustomActionTypeOutput(v **CreateCustomActionTypeOutput, value interface{}) error { 11132 if v == nil { 11133 return fmt.Errorf("unexpected nil of type %T", v) 11134 } 11135 if value == nil { 11136 return nil 11137 } 11138 11139 shape, ok := value.(map[string]interface{}) 11140 if !ok { 11141 return fmt.Errorf("unexpected JSON type %v", value) 11142 } 11143 11144 var sv *CreateCustomActionTypeOutput 11145 if *v == nil { 11146 sv = &CreateCustomActionTypeOutput{} 11147 } else { 11148 sv = *v 11149 } 11150 11151 for key, value := range shape { 11152 switch key { 11153 case "actionType": 11154 if err := awsAwsjson11_deserializeDocumentActionType(&sv.ActionType, value); err != nil { 11155 return err 11156 } 11157 11158 case "tags": 11159 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil { 11160 return err 11161 } 11162 11163 default: 11164 _, _ = key, value 11165 11166 } 11167 } 11168 *v = sv 11169 return nil 11170} 11171 11172func awsAwsjson11_deserializeOpDocumentCreatePipelineOutput(v **CreatePipelineOutput, value interface{}) error { 11173 if v == nil { 11174 return fmt.Errorf("unexpected nil of type %T", v) 11175 } 11176 if value == nil { 11177 return nil 11178 } 11179 11180 shape, ok := value.(map[string]interface{}) 11181 if !ok { 11182 return fmt.Errorf("unexpected JSON type %v", value) 11183 } 11184 11185 var sv *CreatePipelineOutput 11186 if *v == nil { 11187 sv = &CreatePipelineOutput{} 11188 } else { 11189 sv = *v 11190 } 11191 11192 for key, value := range shape { 11193 switch key { 11194 case "pipeline": 11195 if err := awsAwsjson11_deserializeDocumentPipelineDeclaration(&sv.Pipeline, value); err != nil { 11196 return err 11197 } 11198 11199 case "tags": 11200 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil { 11201 return err 11202 } 11203 11204 default: 11205 _, _ = key, value 11206 11207 } 11208 } 11209 *v = sv 11210 return nil 11211} 11212 11213func awsAwsjson11_deserializeOpDocumentDeleteWebhookOutput(v **DeleteWebhookOutput, value interface{}) error { 11214 if v == nil { 11215 return fmt.Errorf("unexpected nil of type %T", v) 11216 } 11217 if value == nil { 11218 return nil 11219 } 11220 11221 shape, ok := value.(map[string]interface{}) 11222 if !ok { 11223 return fmt.Errorf("unexpected JSON type %v", value) 11224 } 11225 11226 var sv *DeleteWebhookOutput 11227 if *v == nil { 11228 sv = &DeleteWebhookOutput{} 11229 } else { 11230 sv = *v 11231 } 11232 11233 for key, value := range shape { 11234 switch key { 11235 default: 11236 _, _ = key, value 11237 11238 } 11239 } 11240 *v = sv 11241 return nil 11242} 11243 11244func awsAwsjson11_deserializeOpDocumentDeregisterWebhookWithThirdPartyOutput(v **DeregisterWebhookWithThirdPartyOutput, value interface{}) error { 11245 if v == nil { 11246 return fmt.Errorf("unexpected nil of type %T", v) 11247 } 11248 if value == nil { 11249 return nil 11250 } 11251 11252 shape, ok := value.(map[string]interface{}) 11253 if !ok { 11254 return fmt.Errorf("unexpected JSON type %v", value) 11255 } 11256 11257 var sv *DeregisterWebhookWithThirdPartyOutput 11258 if *v == nil { 11259 sv = &DeregisterWebhookWithThirdPartyOutput{} 11260 } else { 11261 sv = *v 11262 } 11263 11264 for key, value := range shape { 11265 switch key { 11266 default: 11267 _, _ = key, value 11268 11269 } 11270 } 11271 *v = sv 11272 return nil 11273} 11274 11275func awsAwsjson11_deserializeOpDocumentGetJobDetailsOutput(v **GetJobDetailsOutput, value interface{}) error { 11276 if v == nil { 11277 return fmt.Errorf("unexpected nil of type %T", v) 11278 } 11279 if value == nil { 11280 return nil 11281 } 11282 11283 shape, ok := value.(map[string]interface{}) 11284 if !ok { 11285 return fmt.Errorf("unexpected JSON type %v", value) 11286 } 11287 11288 var sv *GetJobDetailsOutput 11289 if *v == nil { 11290 sv = &GetJobDetailsOutput{} 11291 } else { 11292 sv = *v 11293 } 11294 11295 for key, value := range shape { 11296 switch key { 11297 case "jobDetails": 11298 if err := awsAwsjson11_deserializeDocumentJobDetails(&sv.JobDetails, value); err != nil { 11299 return err 11300 } 11301 11302 default: 11303 _, _ = key, value 11304 11305 } 11306 } 11307 *v = sv 11308 return nil 11309} 11310 11311func awsAwsjson11_deserializeOpDocumentGetPipelineExecutionOutput(v **GetPipelineExecutionOutput, value interface{}) error { 11312 if v == nil { 11313 return fmt.Errorf("unexpected nil of type %T", v) 11314 } 11315 if value == nil { 11316 return nil 11317 } 11318 11319 shape, ok := value.(map[string]interface{}) 11320 if !ok { 11321 return fmt.Errorf("unexpected JSON type %v", value) 11322 } 11323 11324 var sv *GetPipelineExecutionOutput 11325 if *v == nil { 11326 sv = &GetPipelineExecutionOutput{} 11327 } else { 11328 sv = *v 11329 } 11330 11331 for key, value := range shape { 11332 switch key { 11333 case "pipelineExecution": 11334 if err := awsAwsjson11_deserializeDocumentPipelineExecution(&sv.PipelineExecution, value); err != nil { 11335 return err 11336 } 11337 11338 default: 11339 _, _ = key, value 11340 11341 } 11342 } 11343 *v = sv 11344 return nil 11345} 11346 11347func awsAwsjson11_deserializeOpDocumentGetPipelineOutput(v **GetPipelineOutput, value interface{}) error { 11348 if v == nil { 11349 return fmt.Errorf("unexpected nil of type %T", v) 11350 } 11351 if value == nil { 11352 return nil 11353 } 11354 11355 shape, ok := value.(map[string]interface{}) 11356 if !ok { 11357 return fmt.Errorf("unexpected JSON type %v", value) 11358 } 11359 11360 var sv *GetPipelineOutput 11361 if *v == nil { 11362 sv = &GetPipelineOutput{} 11363 } else { 11364 sv = *v 11365 } 11366 11367 for key, value := range shape { 11368 switch key { 11369 case "metadata": 11370 if err := awsAwsjson11_deserializeDocumentPipelineMetadata(&sv.Metadata, value); err != nil { 11371 return err 11372 } 11373 11374 case "pipeline": 11375 if err := awsAwsjson11_deserializeDocumentPipelineDeclaration(&sv.Pipeline, value); err != nil { 11376 return err 11377 } 11378 11379 default: 11380 _, _ = key, value 11381 11382 } 11383 } 11384 *v = sv 11385 return nil 11386} 11387 11388func awsAwsjson11_deserializeOpDocumentGetPipelineStateOutput(v **GetPipelineStateOutput, value interface{}) error { 11389 if v == nil { 11390 return fmt.Errorf("unexpected nil of type %T", v) 11391 } 11392 if value == nil { 11393 return nil 11394 } 11395 11396 shape, ok := value.(map[string]interface{}) 11397 if !ok { 11398 return fmt.Errorf("unexpected JSON type %v", value) 11399 } 11400 11401 var sv *GetPipelineStateOutput 11402 if *v == nil { 11403 sv = &GetPipelineStateOutput{} 11404 } else { 11405 sv = *v 11406 } 11407 11408 for key, value := range shape { 11409 switch key { 11410 case "created": 11411 if value != nil { 11412 jtv, ok := value.(json.Number) 11413 if !ok { 11414 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 11415 } 11416 f64, err := jtv.Float64() 11417 if err != nil { 11418 return err 11419 } 11420 sv.Created = ptr.Time(smithytime.ParseEpochSeconds(f64)) 11421 } 11422 11423 case "pipelineName": 11424 if value != nil { 11425 jtv, ok := value.(string) 11426 if !ok { 11427 return fmt.Errorf("expected PipelineName to be of type string, got %T instead", value) 11428 } 11429 sv.PipelineName = ptr.String(jtv) 11430 } 11431 11432 case "pipelineVersion": 11433 if value != nil { 11434 jtv, ok := value.(json.Number) 11435 if !ok { 11436 return fmt.Errorf("expected PipelineVersion to be json.Number, got %T instead", value) 11437 } 11438 i64, err := jtv.Int64() 11439 if err != nil { 11440 return err 11441 } 11442 sv.PipelineVersion = ptr.Int32(int32(i64)) 11443 } 11444 11445 case "stageStates": 11446 if err := awsAwsjson11_deserializeDocumentStageStateList(&sv.StageStates, value); err != nil { 11447 return err 11448 } 11449 11450 case "updated": 11451 if value != nil { 11452 jtv, ok := value.(json.Number) 11453 if !ok { 11454 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 11455 } 11456 f64, err := jtv.Float64() 11457 if err != nil { 11458 return err 11459 } 11460 sv.Updated = ptr.Time(smithytime.ParseEpochSeconds(f64)) 11461 } 11462 11463 default: 11464 _, _ = key, value 11465 11466 } 11467 } 11468 *v = sv 11469 return nil 11470} 11471 11472func awsAwsjson11_deserializeOpDocumentGetThirdPartyJobDetailsOutput(v **GetThirdPartyJobDetailsOutput, value interface{}) error { 11473 if v == nil { 11474 return fmt.Errorf("unexpected nil of type %T", v) 11475 } 11476 if value == nil { 11477 return nil 11478 } 11479 11480 shape, ok := value.(map[string]interface{}) 11481 if !ok { 11482 return fmt.Errorf("unexpected JSON type %v", value) 11483 } 11484 11485 var sv *GetThirdPartyJobDetailsOutput 11486 if *v == nil { 11487 sv = &GetThirdPartyJobDetailsOutput{} 11488 } else { 11489 sv = *v 11490 } 11491 11492 for key, value := range shape { 11493 switch key { 11494 case "jobDetails": 11495 if err := awsAwsjson11_deserializeDocumentThirdPartyJobDetails(&sv.JobDetails, value); err != nil { 11496 return err 11497 } 11498 11499 default: 11500 _, _ = key, value 11501 11502 } 11503 } 11504 *v = sv 11505 return nil 11506} 11507 11508func awsAwsjson11_deserializeOpDocumentListActionExecutionsOutput(v **ListActionExecutionsOutput, value interface{}) error { 11509 if v == nil { 11510 return fmt.Errorf("unexpected nil of type %T", v) 11511 } 11512 if value == nil { 11513 return nil 11514 } 11515 11516 shape, ok := value.(map[string]interface{}) 11517 if !ok { 11518 return fmt.Errorf("unexpected JSON type %v", value) 11519 } 11520 11521 var sv *ListActionExecutionsOutput 11522 if *v == nil { 11523 sv = &ListActionExecutionsOutput{} 11524 } else { 11525 sv = *v 11526 } 11527 11528 for key, value := range shape { 11529 switch key { 11530 case "actionExecutionDetails": 11531 if err := awsAwsjson11_deserializeDocumentActionExecutionDetailList(&sv.ActionExecutionDetails, value); err != nil { 11532 return err 11533 } 11534 11535 case "nextToken": 11536 if value != nil { 11537 jtv, ok := value.(string) 11538 if !ok { 11539 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 11540 } 11541 sv.NextToken = ptr.String(jtv) 11542 } 11543 11544 default: 11545 _, _ = key, value 11546 11547 } 11548 } 11549 *v = sv 11550 return nil 11551} 11552 11553func awsAwsjson11_deserializeOpDocumentListActionTypesOutput(v **ListActionTypesOutput, value interface{}) error { 11554 if v == nil { 11555 return fmt.Errorf("unexpected nil of type %T", v) 11556 } 11557 if value == nil { 11558 return nil 11559 } 11560 11561 shape, ok := value.(map[string]interface{}) 11562 if !ok { 11563 return fmt.Errorf("unexpected JSON type %v", value) 11564 } 11565 11566 var sv *ListActionTypesOutput 11567 if *v == nil { 11568 sv = &ListActionTypesOutput{} 11569 } else { 11570 sv = *v 11571 } 11572 11573 for key, value := range shape { 11574 switch key { 11575 case "actionTypes": 11576 if err := awsAwsjson11_deserializeDocumentActionTypeList(&sv.ActionTypes, value); err != nil { 11577 return err 11578 } 11579 11580 case "nextToken": 11581 if value != nil { 11582 jtv, ok := value.(string) 11583 if !ok { 11584 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 11585 } 11586 sv.NextToken = ptr.String(jtv) 11587 } 11588 11589 default: 11590 _, _ = key, value 11591 11592 } 11593 } 11594 *v = sv 11595 return nil 11596} 11597 11598func awsAwsjson11_deserializeOpDocumentListPipelineExecutionsOutput(v **ListPipelineExecutionsOutput, value interface{}) error { 11599 if v == nil { 11600 return fmt.Errorf("unexpected nil of type %T", v) 11601 } 11602 if value == nil { 11603 return nil 11604 } 11605 11606 shape, ok := value.(map[string]interface{}) 11607 if !ok { 11608 return fmt.Errorf("unexpected JSON type %v", value) 11609 } 11610 11611 var sv *ListPipelineExecutionsOutput 11612 if *v == nil { 11613 sv = &ListPipelineExecutionsOutput{} 11614 } else { 11615 sv = *v 11616 } 11617 11618 for key, value := range shape { 11619 switch key { 11620 case "nextToken": 11621 if value != nil { 11622 jtv, ok := value.(string) 11623 if !ok { 11624 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 11625 } 11626 sv.NextToken = ptr.String(jtv) 11627 } 11628 11629 case "pipelineExecutionSummaries": 11630 if err := awsAwsjson11_deserializeDocumentPipelineExecutionSummaryList(&sv.PipelineExecutionSummaries, value); err != nil { 11631 return err 11632 } 11633 11634 default: 11635 _, _ = key, value 11636 11637 } 11638 } 11639 *v = sv 11640 return nil 11641} 11642 11643func awsAwsjson11_deserializeOpDocumentListPipelinesOutput(v **ListPipelinesOutput, value interface{}) error { 11644 if v == nil { 11645 return fmt.Errorf("unexpected nil of type %T", v) 11646 } 11647 if value == nil { 11648 return nil 11649 } 11650 11651 shape, ok := value.(map[string]interface{}) 11652 if !ok { 11653 return fmt.Errorf("unexpected JSON type %v", value) 11654 } 11655 11656 var sv *ListPipelinesOutput 11657 if *v == nil { 11658 sv = &ListPipelinesOutput{} 11659 } else { 11660 sv = *v 11661 } 11662 11663 for key, value := range shape { 11664 switch key { 11665 case "nextToken": 11666 if value != nil { 11667 jtv, ok := value.(string) 11668 if !ok { 11669 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 11670 } 11671 sv.NextToken = ptr.String(jtv) 11672 } 11673 11674 case "pipelines": 11675 if err := awsAwsjson11_deserializeDocumentPipelineList(&sv.Pipelines, value); err != nil { 11676 return err 11677 } 11678 11679 default: 11680 _, _ = key, value 11681 11682 } 11683 } 11684 *v = sv 11685 return nil 11686} 11687 11688func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 11689 if v == nil { 11690 return fmt.Errorf("unexpected nil of type %T", v) 11691 } 11692 if value == nil { 11693 return nil 11694 } 11695 11696 shape, ok := value.(map[string]interface{}) 11697 if !ok { 11698 return fmt.Errorf("unexpected JSON type %v", value) 11699 } 11700 11701 var sv *ListTagsForResourceOutput 11702 if *v == nil { 11703 sv = &ListTagsForResourceOutput{} 11704 } else { 11705 sv = *v 11706 } 11707 11708 for key, value := range shape { 11709 switch key { 11710 case "nextToken": 11711 if value != nil { 11712 jtv, ok := value.(string) 11713 if !ok { 11714 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 11715 } 11716 sv.NextToken = ptr.String(jtv) 11717 } 11718 11719 case "tags": 11720 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil { 11721 return err 11722 } 11723 11724 default: 11725 _, _ = key, value 11726 11727 } 11728 } 11729 *v = sv 11730 return nil 11731} 11732 11733func awsAwsjson11_deserializeOpDocumentListWebhooksOutput(v **ListWebhooksOutput, value interface{}) error { 11734 if v == nil { 11735 return fmt.Errorf("unexpected nil of type %T", v) 11736 } 11737 if value == nil { 11738 return nil 11739 } 11740 11741 shape, ok := value.(map[string]interface{}) 11742 if !ok { 11743 return fmt.Errorf("unexpected JSON type %v", value) 11744 } 11745 11746 var sv *ListWebhooksOutput 11747 if *v == nil { 11748 sv = &ListWebhooksOutput{} 11749 } else { 11750 sv = *v 11751 } 11752 11753 for key, value := range shape { 11754 switch key { 11755 case "NextToken": 11756 if value != nil { 11757 jtv, ok := value.(string) 11758 if !ok { 11759 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 11760 } 11761 sv.NextToken = ptr.String(jtv) 11762 } 11763 11764 case "webhooks": 11765 if err := awsAwsjson11_deserializeDocumentWebhookList(&sv.Webhooks, value); err != nil { 11766 return err 11767 } 11768 11769 default: 11770 _, _ = key, value 11771 11772 } 11773 } 11774 *v = sv 11775 return nil 11776} 11777 11778func awsAwsjson11_deserializeOpDocumentPollForJobsOutput(v **PollForJobsOutput, value interface{}) error { 11779 if v == nil { 11780 return fmt.Errorf("unexpected nil of type %T", v) 11781 } 11782 if value == nil { 11783 return nil 11784 } 11785 11786 shape, ok := value.(map[string]interface{}) 11787 if !ok { 11788 return fmt.Errorf("unexpected JSON type %v", value) 11789 } 11790 11791 var sv *PollForJobsOutput 11792 if *v == nil { 11793 sv = &PollForJobsOutput{} 11794 } else { 11795 sv = *v 11796 } 11797 11798 for key, value := range shape { 11799 switch key { 11800 case "jobs": 11801 if err := awsAwsjson11_deserializeDocumentJobList(&sv.Jobs, value); err != nil { 11802 return err 11803 } 11804 11805 default: 11806 _, _ = key, value 11807 11808 } 11809 } 11810 *v = sv 11811 return nil 11812} 11813 11814func awsAwsjson11_deserializeOpDocumentPollForThirdPartyJobsOutput(v **PollForThirdPartyJobsOutput, value interface{}) error { 11815 if v == nil { 11816 return fmt.Errorf("unexpected nil of type %T", v) 11817 } 11818 if value == nil { 11819 return nil 11820 } 11821 11822 shape, ok := value.(map[string]interface{}) 11823 if !ok { 11824 return fmt.Errorf("unexpected JSON type %v", value) 11825 } 11826 11827 var sv *PollForThirdPartyJobsOutput 11828 if *v == nil { 11829 sv = &PollForThirdPartyJobsOutput{} 11830 } else { 11831 sv = *v 11832 } 11833 11834 for key, value := range shape { 11835 switch key { 11836 case "jobs": 11837 if err := awsAwsjson11_deserializeDocumentThirdPartyJobList(&sv.Jobs, value); err != nil { 11838 return err 11839 } 11840 11841 default: 11842 _, _ = key, value 11843 11844 } 11845 } 11846 *v = sv 11847 return nil 11848} 11849 11850func awsAwsjson11_deserializeOpDocumentPutActionRevisionOutput(v **PutActionRevisionOutput, value interface{}) error { 11851 if v == nil { 11852 return fmt.Errorf("unexpected nil of type %T", v) 11853 } 11854 if value == nil { 11855 return nil 11856 } 11857 11858 shape, ok := value.(map[string]interface{}) 11859 if !ok { 11860 return fmt.Errorf("unexpected JSON type %v", value) 11861 } 11862 11863 var sv *PutActionRevisionOutput 11864 if *v == nil { 11865 sv = &PutActionRevisionOutput{} 11866 } else { 11867 sv = *v 11868 } 11869 11870 for key, value := range shape { 11871 switch key { 11872 case "newRevision": 11873 if value != nil { 11874 jtv, ok := value.(bool) 11875 if !ok { 11876 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 11877 } 11878 sv.NewRevision = jtv 11879 } 11880 11881 case "pipelineExecutionId": 11882 if value != nil { 11883 jtv, ok := value.(string) 11884 if !ok { 11885 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 11886 } 11887 sv.PipelineExecutionId = ptr.String(jtv) 11888 } 11889 11890 default: 11891 _, _ = key, value 11892 11893 } 11894 } 11895 *v = sv 11896 return nil 11897} 11898 11899func awsAwsjson11_deserializeOpDocumentPutApprovalResultOutput(v **PutApprovalResultOutput, value interface{}) error { 11900 if v == nil { 11901 return fmt.Errorf("unexpected nil of type %T", v) 11902 } 11903 if value == nil { 11904 return nil 11905 } 11906 11907 shape, ok := value.(map[string]interface{}) 11908 if !ok { 11909 return fmt.Errorf("unexpected JSON type %v", value) 11910 } 11911 11912 var sv *PutApprovalResultOutput 11913 if *v == nil { 11914 sv = &PutApprovalResultOutput{} 11915 } else { 11916 sv = *v 11917 } 11918 11919 for key, value := range shape { 11920 switch key { 11921 case "approvedAt": 11922 if value != nil { 11923 jtv, ok := value.(json.Number) 11924 if !ok { 11925 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 11926 } 11927 f64, err := jtv.Float64() 11928 if err != nil { 11929 return err 11930 } 11931 sv.ApprovedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 11932 } 11933 11934 default: 11935 _, _ = key, value 11936 11937 } 11938 } 11939 *v = sv 11940 return nil 11941} 11942 11943func awsAwsjson11_deserializeOpDocumentPutWebhookOutput(v **PutWebhookOutput, value interface{}) error { 11944 if v == nil { 11945 return fmt.Errorf("unexpected nil of type %T", v) 11946 } 11947 if value == nil { 11948 return nil 11949 } 11950 11951 shape, ok := value.(map[string]interface{}) 11952 if !ok { 11953 return fmt.Errorf("unexpected JSON type %v", value) 11954 } 11955 11956 var sv *PutWebhookOutput 11957 if *v == nil { 11958 sv = &PutWebhookOutput{} 11959 } else { 11960 sv = *v 11961 } 11962 11963 for key, value := range shape { 11964 switch key { 11965 case "webhook": 11966 if err := awsAwsjson11_deserializeDocumentListWebhookItem(&sv.Webhook, value); err != nil { 11967 return err 11968 } 11969 11970 default: 11971 _, _ = key, value 11972 11973 } 11974 } 11975 *v = sv 11976 return nil 11977} 11978 11979func awsAwsjson11_deserializeOpDocumentRegisterWebhookWithThirdPartyOutput(v **RegisterWebhookWithThirdPartyOutput, value interface{}) error { 11980 if v == nil { 11981 return fmt.Errorf("unexpected nil of type %T", v) 11982 } 11983 if value == nil { 11984 return nil 11985 } 11986 11987 shape, ok := value.(map[string]interface{}) 11988 if !ok { 11989 return fmt.Errorf("unexpected JSON type %v", value) 11990 } 11991 11992 var sv *RegisterWebhookWithThirdPartyOutput 11993 if *v == nil { 11994 sv = &RegisterWebhookWithThirdPartyOutput{} 11995 } else { 11996 sv = *v 11997 } 11998 11999 for key, value := range shape { 12000 switch key { 12001 default: 12002 _, _ = key, value 12003 12004 } 12005 } 12006 *v = sv 12007 return nil 12008} 12009 12010func awsAwsjson11_deserializeOpDocumentRetryStageExecutionOutput(v **RetryStageExecutionOutput, value interface{}) error { 12011 if v == nil { 12012 return fmt.Errorf("unexpected nil of type %T", v) 12013 } 12014 if value == nil { 12015 return nil 12016 } 12017 12018 shape, ok := value.(map[string]interface{}) 12019 if !ok { 12020 return fmt.Errorf("unexpected JSON type %v", value) 12021 } 12022 12023 var sv *RetryStageExecutionOutput 12024 if *v == nil { 12025 sv = &RetryStageExecutionOutput{} 12026 } else { 12027 sv = *v 12028 } 12029 12030 for key, value := range shape { 12031 switch key { 12032 case "pipelineExecutionId": 12033 if value != nil { 12034 jtv, ok := value.(string) 12035 if !ok { 12036 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 12037 } 12038 sv.PipelineExecutionId = ptr.String(jtv) 12039 } 12040 12041 default: 12042 _, _ = key, value 12043 12044 } 12045 } 12046 *v = sv 12047 return nil 12048} 12049 12050func awsAwsjson11_deserializeOpDocumentStartPipelineExecutionOutput(v **StartPipelineExecutionOutput, value interface{}) error { 12051 if v == nil { 12052 return fmt.Errorf("unexpected nil of type %T", v) 12053 } 12054 if value == nil { 12055 return nil 12056 } 12057 12058 shape, ok := value.(map[string]interface{}) 12059 if !ok { 12060 return fmt.Errorf("unexpected JSON type %v", value) 12061 } 12062 12063 var sv *StartPipelineExecutionOutput 12064 if *v == nil { 12065 sv = &StartPipelineExecutionOutput{} 12066 } else { 12067 sv = *v 12068 } 12069 12070 for key, value := range shape { 12071 switch key { 12072 case "pipelineExecutionId": 12073 if value != nil { 12074 jtv, ok := value.(string) 12075 if !ok { 12076 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 12077 } 12078 sv.PipelineExecutionId = ptr.String(jtv) 12079 } 12080 12081 default: 12082 _, _ = key, value 12083 12084 } 12085 } 12086 *v = sv 12087 return nil 12088} 12089 12090func awsAwsjson11_deserializeOpDocumentStopPipelineExecutionOutput(v **StopPipelineExecutionOutput, value interface{}) error { 12091 if v == nil { 12092 return fmt.Errorf("unexpected nil of type %T", v) 12093 } 12094 if value == nil { 12095 return nil 12096 } 12097 12098 shape, ok := value.(map[string]interface{}) 12099 if !ok { 12100 return fmt.Errorf("unexpected JSON type %v", value) 12101 } 12102 12103 var sv *StopPipelineExecutionOutput 12104 if *v == nil { 12105 sv = &StopPipelineExecutionOutput{} 12106 } else { 12107 sv = *v 12108 } 12109 12110 for key, value := range shape { 12111 switch key { 12112 case "pipelineExecutionId": 12113 if value != nil { 12114 jtv, ok := value.(string) 12115 if !ok { 12116 return fmt.Errorf("expected PipelineExecutionId to be of type string, got %T instead", value) 12117 } 12118 sv.PipelineExecutionId = ptr.String(jtv) 12119 } 12120 12121 default: 12122 _, _ = key, value 12123 12124 } 12125 } 12126 *v = sv 12127 return nil 12128} 12129 12130func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error { 12131 if v == nil { 12132 return fmt.Errorf("unexpected nil of type %T", v) 12133 } 12134 if value == nil { 12135 return nil 12136 } 12137 12138 shape, ok := value.(map[string]interface{}) 12139 if !ok { 12140 return fmt.Errorf("unexpected JSON type %v", value) 12141 } 12142 12143 var sv *TagResourceOutput 12144 if *v == nil { 12145 sv = &TagResourceOutput{} 12146 } else { 12147 sv = *v 12148 } 12149 12150 for key, value := range shape { 12151 switch key { 12152 default: 12153 _, _ = key, value 12154 12155 } 12156 } 12157 *v = sv 12158 return nil 12159} 12160 12161func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error { 12162 if v == nil { 12163 return fmt.Errorf("unexpected nil of type %T", v) 12164 } 12165 if value == nil { 12166 return nil 12167 } 12168 12169 shape, ok := value.(map[string]interface{}) 12170 if !ok { 12171 return fmt.Errorf("unexpected JSON type %v", value) 12172 } 12173 12174 var sv *UntagResourceOutput 12175 if *v == nil { 12176 sv = &UntagResourceOutput{} 12177 } else { 12178 sv = *v 12179 } 12180 12181 for key, value := range shape { 12182 switch key { 12183 default: 12184 _, _ = key, value 12185 12186 } 12187 } 12188 *v = sv 12189 return nil 12190} 12191 12192func awsAwsjson11_deserializeOpDocumentUpdatePipelineOutput(v **UpdatePipelineOutput, value interface{}) error { 12193 if v == nil { 12194 return fmt.Errorf("unexpected nil of type %T", v) 12195 } 12196 if value == nil { 12197 return nil 12198 } 12199 12200 shape, ok := value.(map[string]interface{}) 12201 if !ok { 12202 return fmt.Errorf("unexpected JSON type %v", value) 12203 } 12204 12205 var sv *UpdatePipelineOutput 12206 if *v == nil { 12207 sv = &UpdatePipelineOutput{} 12208 } else { 12209 sv = *v 12210 } 12211 12212 for key, value := range shape { 12213 switch key { 12214 case "pipeline": 12215 if err := awsAwsjson11_deserializeDocumentPipelineDeclaration(&sv.Pipeline, value); err != nil { 12216 return err 12217 } 12218 12219 default: 12220 _, _ = key, value 12221 12222 } 12223 } 12224 *v = sv 12225 return nil 12226} 12227