1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package swf 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/swf/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 awsAwsjson10_deserializeOpCountClosedWorkflowExecutions struct { 24} 25 26func (*awsAwsjson10_deserializeOpCountClosedWorkflowExecutions) ID() string { 27 return "OperationDeserializer" 28} 29 30func (m *awsAwsjson10_deserializeOpCountClosedWorkflowExecutions) 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, awsAwsjson10_deserializeOpErrorCountClosedWorkflowExecutions(response, &metadata) 45 } 46 output := &CountClosedWorkflowExecutionsOutput{} 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 = awsAwsjson10_deserializeOpDocumentCountClosedWorkflowExecutionsOutput(&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 awsAwsjson10_deserializeOpErrorCountClosedWorkflowExecutions(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("OperationNotPermittedFault", errorCode): 122 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 123 124 case strings.EqualFold("UnknownResourceFault", errorCode): 125 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 126 127 default: 128 genericError := &smithy.GenericAPIError{ 129 Code: errorCode, 130 Message: errorMessage, 131 } 132 return genericError 133 134 } 135} 136 137type awsAwsjson10_deserializeOpCountOpenWorkflowExecutions struct { 138} 139 140func (*awsAwsjson10_deserializeOpCountOpenWorkflowExecutions) ID() string { 141 return "OperationDeserializer" 142} 143 144func (m *awsAwsjson10_deserializeOpCountOpenWorkflowExecutions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 145 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 146) { 147 out, metadata, err = next.HandleDeserialize(ctx, in) 148 if err != nil { 149 return out, metadata, err 150 } 151 152 response, ok := out.RawResponse.(*smithyhttp.Response) 153 if !ok { 154 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 155 } 156 157 if response.StatusCode < 200 || response.StatusCode >= 300 { 158 return out, metadata, awsAwsjson10_deserializeOpErrorCountOpenWorkflowExecutions(response, &metadata) 159 } 160 output := &CountOpenWorkflowExecutionsOutput{} 161 out.Result = output 162 163 var buff [1024]byte 164 ringBuffer := smithyio.NewRingBuffer(buff[:]) 165 166 body := io.TeeReader(response.Body, ringBuffer) 167 decoder := json.NewDecoder(body) 168 decoder.UseNumber() 169 var shape interface{} 170 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 171 var snapshot bytes.Buffer 172 io.Copy(&snapshot, ringBuffer) 173 err = &smithy.DeserializationError{ 174 Err: fmt.Errorf("failed to decode response body, %w", err), 175 Snapshot: snapshot.Bytes(), 176 } 177 return out, metadata, err 178 } 179 180 err = awsAwsjson10_deserializeOpDocumentCountOpenWorkflowExecutionsOutput(&output, shape) 181 if err != nil { 182 var snapshot bytes.Buffer 183 io.Copy(&snapshot, ringBuffer) 184 err = &smithy.DeserializationError{ 185 Err: fmt.Errorf("failed to decode response body, %w", err), 186 Snapshot: snapshot.Bytes(), 187 } 188 return out, metadata, err 189 } 190 191 return out, metadata, err 192} 193 194func awsAwsjson10_deserializeOpErrorCountOpenWorkflowExecutions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 195 var errorBuffer bytes.Buffer 196 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 197 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 198 } 199 errorBody := bytes.NewReader(errorBuffer.Bytes()) 200 201 errorCode := "UnknownError" 202 errorMessage := errorCode 203 204 code := response.Header.Get("X-Amzn-ErrorType") 205 if len(code) != 0 { 206 errorCode = restjson.SanitizeErrorCode(code) 207 } 208 209 var buff [1024]byte 210 ringBuffer := smithyio.NewRingBuffer(buff[:]) 211 212 body := io.TeeReader(errorBody, ringBuffer) 213 decoder := json.NewDecoder(body) 214 decoder.UseNumber() 215 code, message, err := restjson.GetErrorInfo(decoder) 216 if err != nil { 217 var snapshot bytes.Buffer 218 io.Copy(&snapshot, ringBuffer) 219 err = &smithy.DeserializationError{ 220 Err: fmt.Errorf("failed to decode response body, %w", err), 221 Snapshot: snapshot.Bytes(), 222 } 223 return err 224 } 225 226 errorBody.Seek(0, io.SeekStart) 227 if len(code) != 0 { 228 errorCode = restjson.SanitizeErrorCode(code) 229 } 230 if len(message) != 0 { 231 errorMessage = message 232 } 233 234 switch { 235 case strings.EqualFold("OperationNotPermittedFault", errorCode): 236 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 237 238 case strings.EqualFold("UnknownResourceFault", errorCode): 239 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 240 241 default: 242 genericError := &smithy.GenericAPIError{ 243 Code: errorCode, 244 Message: errorMessage, 245 } 246 return genericError 247 248 } 249} 250 251type awsAwsjson10_deserializeOpCountPendingActivityTasks struct { 252} 253 254func (*awsAwsjson10_deserializeOpCountPendingActivityTasks) ID() string { 255 return "OperationDeserializer" 256} 257 258func (m *awsAwsjson10_deserializeOpCountPendingActivityTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 259 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 260) { 261 out, metadata, err = next.HandleDeserialize(ctx, in) 262 if err != nil { 263 return out, metadata, err 264 } 265 266 response, ok := out.RawResponse.(*smithyhttp.Response) 267 if !ok { 268 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 269 } 270 271 if response.StatusCode < 200 || response.StatusCode >= 300 { 272 return out, metadata, awsAwsjson10_deserializeOpErrorCountPendingActivityTasks(response, &metadata) 273 } 274 output := &CountPendingActivityTasksOutput{} 275 out.Result = output 276 277 var buff [1024]byte 278 ringBuffer := smithyio.NewRingBuffer(buff[:]) 279 280 body := io.TeeReader(response.Body, ringBuffer) 281 decoder := json.NewDecoder(body) 282 decoder.UseNumber() 283 var shape interface{} 284 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 285 var snapshot bytes.Buffer 286 io.Copy(&snapshot, ringBuffer) 287 err = &smithy.DeserializationError{ 288 Err: fmt.Errorf("failed to decode response body, %w", err), 289 Snapshot: snapshot.Bytes(), 290 } 291 return out, metadata, err 292 } 293 294 err = awsAwsjson10_deserializeOpDocumentCountPendingActivityTasksOutput(&output, shape) 295 if err != nil { 296 var snapshot bytes.Buffer 297 io.Copy(&snapshot, ringBuffer) 298 err = &smithy.DeserializationError{ 299 Err: fmt.Errorf("failed to decode response body, %w", err), 300 Snapshot: snapshot.Bytes(), 301 } 302 return out, metadata, err 303 } 304 305 return out, metadata, err 306} 307 308func awsAwsjson10_deserializeOpErrorCountPendingActivityTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error { 309 var errorBuffer bytes.Buffer 310 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 311 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 312 } 313 errorBody := bytes.NewReader(errorBuffer.Bytes()) 314 315 errorCode := "UnknownError" 316 errorMessage := errorCode 317 318 code := response.Header.Get("X-Amzn-ErrorType") 319 if len(code) != 0 { 320 errorCode = restjson.SanitizeErrorCode(code) 321 } 322 323 var buff [1024]byte 324 ringBuffer := smithyio.NewRingBuffer(buff[:]) 325 326 body := io.TeeReader(errorBody, ringBuffer) 327 decoder := json.NewDecoder(body) 328 decoder.UseNumber() 329 code, message, err := restjson.GetErrorInfo(decoder) 330 if err != nil { 331 var snapshot bytes.Buffer 332 io.Copy(&snapshot, ringBuffer) 333 err = &smithy.DeserializationError{ 334 Err: fmt.Errorf("failed to decode response body, %w", err), 335 Snapshot: snapshot.Bytes(), 336 } 337 return err 338 } 339 340 errorBody.Seek(0, io.SeekStart) 341 if len(code) != 0 { 342 errorCode = restjson.SanitizeErrorCode(code) 343 } 344 if len(message) != 0 { 345 errorMessage = message 346 } 347 348 switch { 349 case strings.EqualFold("OperationNotPermittedFault", errorCode): 350 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 351 352 case strings.EqualFold("UnknownResourceFault", errorCode): 353 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 354 355 default: 356 genericError := &smithy.GenericAPIError{ 357 Code: errorCode, 358 Message: errorMessage, 359 } 360 return genericError 361 362 } 363} 364 365type awsAwsjson10_deserializeOpCountPendingDecisionTasks struct { 366} 367 368func (*awsAwsjson10_deserializeOpCountPendingDecisionTasks) ID() string { 369 return "OperationDeserializer" 370} 371 372func (m *awsAwsjson10_deserializeOpCountPendingDecisionTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 373 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 374) { 375 out, metadata, err = next.HandleDeserialize(ctx, in) 376 if err != nil { 377 return out, metadata, err 378 } 379 380 response, ok := out.RawResponse.(*smithyhttp.Response) 381 if !ok { 382 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 383 } 384 385 if response.StatusCode < 200 || response.StatusCode >= 300 { 386 return out, metadata, awsAwsjson10_deserializeOpErrorCountPendingDecisionTasks(response, &metadata) 387 } 388 output := &CountPendingDecisionTasksOutput{} 389 out.Result = output 390 391 var buff [1024]byte 392 ringBuffer := smithyio.NewRingBuffer(buff[:]) 393 394 body := io.TeeReader(response.Body, ringBuffer) 395 decoder := json.NewDecoder(body) 396 decoder.UseNumber() 397 var shape interface{} 398 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 399 var snapshot bytes.Buffer 400 io.Copy(&snapshot, ringBuffer) 401 err = &smithy.DeserializationError{ 402 Err: fmt.Errorf("failed to decode response body, %w", err), 403 Snapshot: snapshot.Bytes(), 404 } 405 return out, metadata, err 406 } 407 408 err = awsAwsjson10_deserializeOpDocumentCountPendingDecisionTasksOutput(&output, shape) 409 if err != nil { 410 var snapshot bytes.Buffer 411 io.Copy(&snapshot, ringBuffer) 412 err = &smithy.DeserializationError{ 413 Err: fmt.Errorf("failed to decode response body, %w", err), 414 Snapshot: snapshot.Bytes(), 415 } 416 return out, metadata, err 417 } 418 419 return out, metadata, err 420} 421 422func awsAwsjson10_deserializeOpErrorCountPendingDecisionTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error { 423 var errorBuffer bytes.Buffer 424 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 425 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 426 } 427 errorBody := bytes.NewReader(errorBuffer.Bytes()) 428 429 errorCode := "UnknownError" 430 errorMessage := errorCode 431 432 code := response.Header.Get("X-Amzn-ErrorType") 433 if len(code) != 0 { 434 errorCode = restjson.SanitizeErrorCode(code) 435 } 436 437 var buff [1024]byte 438 ringBuffer := smithyio.NewRingBuffer(buff[:]) 439 440 body := io.TeeReader(errorBody, ringBuffer) 441 decoder := json.NewDecoder(body) 442 decoder.UseNumber() 443 code, message, err := restjson.GetErrorInfo(decoder) 444 if err != nil { 445 var snapshot bytes.Buffer 446 io.Copy(&snapshot, ringBuffer) 447 err = &smithy.DeserializationError{ 448 Err: fmt.Errorf("failed to decode response body, %w", err), 449 Snapshot: snapshot.Bytes(), 450 } 451 return err 452 } 453 454 errorBody.Seek(0, io.SeekStart) 455 if len(code) != 0 { 456 errorCode = restjson.SanitizeErrorCode(code) 457 } 458 if len(message) != 0 { 459 errorMessage = message 460 } 461 462 switch { 463 case strings.EqualFold("OperationNotPermittedFault", errorCode): 464 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 465 466 case strings.EqualFold("UnknownResourceFault", errorCode): 467 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 468 469 default: 470 genericError := &smithy.GenericAPIError{ 471 Code: errorCode, 472 Message: errorMessage, 473 } 474 return genericError 475 476 } 477} 478 479type awsAwsjson10_deserializeOpDeprecateActivityType struct { 480} 481 482func (*awsAwsjson10_deserializeOpDeprecateActivityType) ID() string { 483 return "OperationDeserializer" 484} 485 486func (m *awsAwsjson10_deserializeOpDeprecateActivityType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 487 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 488) { 489 out, metadata, err = next.HandleDeserialize(ctx, in) 490 if err != nil { 491 return out, metadata, err 492 } 493 494 response, ok := out.RawResponse.(*smithyhttp.Response) 495 if !ok { 496 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 497 } 498 499 if response.StatusCode < 200 || response.StatusCode >= 300 { 500 return out, metadata, awsAwsjson10_deserializeOpErrorDeprecateActivityType(response, &metadata) 501 } 502 output := &DeprecateActivityTypeOutput{} 503 out.Result = output 504 505 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 506 return out, metadata, &smithy.DeserializationError{ 507 Err: fmt.Errorf("failed to discard response body, %w", err), 508 } 509 } 510 511 return out, metadata, err 512} 513 514func awsAwsjson10_deserializeOpErrorDeprecateActivityType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 515 var errorBuffer bytes.Buffer 516 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 517 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 518 } 519 errorBody := bytes.NewReader(errorBuffer.Bytes()) 520 521 errorCode := "UnknownError" 522 errorMessage := errorCode 523 524 code := response.Header.Get("X-Amzn-ErrorType") 525 if len(code) != 0 { 526 errorCode = restjson.SanitizeErrorCode(code) 527 } 528 529 var buff [1024]byte 530 ringBuffer := smithyio.NewRingBuffer(buff[:]) 531 532 body := io.TeeReader(errorBody, ringBuffer) 533 decoder := json.NewDecoder(body) 534 decoder.UseNumber() 535 code, message, err := restjson.GetErrorInfo(decoder) 536 if err != nil { 537 var snapshot bytes.Buffer 538 io.Copy(&snapshot, ringBuffer) 539 err = &smithy.DeserializationError{ 540 Err: fmt.Errorf("failed to decode response body, %w", err), 541 Snapshot: snapshot.Bytes(), 542 } 543 return err 544 } 545 546 errorBody.Seek(0, io.SeekStart) 547 if len(code) != 0 { 548 errorCode = restjson.SanitizeErrorCode(code) 549 } 550 if len(message) != 0 { 551 errorMessage = message 552 } 553 554 switch { 555 case strings.EqualFold("OperationNotPermittedFault", errorCode): 556 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 557 558 case strings.EqualFold("TypeDeprecatedFault", errorCode): 559 return awsAwsjson10_deserializeErrorTypeDeprecatedFault(response, errorBody) 560 561 case strings.EqualFold("UnknownResourceFault", errorCode): 562 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 563 564 default: 565 genericError := &smithy.GenericAPIError{ 566 Code: errorCode, 567 Message: errorMessage, 568 } 569 return genericError 570 571 } 572} 573 574type awsAwsjson10_deserializeOpDeprecateDomain struct { 575} 576 577func (*awsAwsjson10_deserializeOpDeprecateDomain) ID() string { 578 return "OperationDeserializer" 579} 580 581func (m *awsAwsjson10_deserializeOpDeprecateDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 582 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 583) { 584 out, metadata, err = next.HandleDeserialize(ctx, in) 585 if err != nil { 586 return out, metadata, err 587 } 588 589 response, ok := out.RawResponse.(*smithyhttp.Response) 590 if !ok { 591 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 592 } 593 594 if response.StatusCode < 200 || response.StatusCode >= 300 { 595 return out, metadata, awsAwsjson10_deserializeOpErrorDeprecateDomain(response, &metadata) 596 } 597 output := &DeprecateDomainOutput{} 598 out.Result = output 599 600 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 601 return out, metadata, &smithy.DeserializationError{ 602 Err: fmt.Errorf("failed to discard response body, %w", err), 603 } 604 } 605 606 return out, metadata, err 607} 608 609func awsAwsjson10_deserializeOpErrorDeprecateDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { 610 var errorBuffer bytes.Buffer 611 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 612 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 613 } 614 errorBody := bytes.NewReader(errorBuffer.Bytes()) 615 616 errorCode := "UnknownError" 617 errorMessage := errorCode 618 619 code := response.Header.Get("X-Amzn-ErrorType") 620 if len(code) != 0 { 621 errorCode = restjson.SanitizeErrorCode(code) 622 } 623 624 var buff [1024]byte 625 ringBuffer := smithyio.NewRingBuffer(buff[:]) 626 627 body := io.TeeReader(errorBody, ringBuffer) 628 decoder := json.NewDecoder(body) 629 decoder.UseNumber() 630 code, message, err := restjson.GetErrorInfo(decoder) 631 if err != nil { 632 var snapshot bytes.Buffer 633 io.Copy(&snapshot, ringBuffer) 634 err = &smithy.DeserializationError{ 635 Err: fmt.Errorf("failed to decode response body, %w", err), 636 Snapshot: snapshot.Bytes(), 637 } 638 return err 639 } 640 641 errorBody.Seek(0, io.SeekStart) 642 if len(code) != 0 { 643 errorCode = restjson.SanitizeErrorCode(code) 644 } 645 if len(message) != 0 { 646 errorMessage = message 647 } 648 649 switch { 650 case strings.EqualFold("DomainDeprecatedFault", errorCode): 651 return awsAwsjson10_deserializeErrorDomainDeprecatedFault(response, errorBody) 652 653 case strings.EqualFold("OperationNotPermittedFault", errorCode): 654 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 655 656 case strings.EqualFold("UnknownResourceFault", errorCode): 657 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 658 659 default: 660 genericError := &smithy.GenericAPIError{ 661 Code: errorCode, 662 Message: errorMessage, 663 } 664 return genericError 665 666 } 667} 668 669type awsAwsjson10_deserializeOpDeprecateWorkflowType struct { 670} 671 672func (*awsAwsjson10_deserializeOpDeprecateWorkflowType) ID() string { 673 return "OperationDeserializer" 674} 675 676func (m *awsAwsjson10_deserializeOpDeprecateWorkflowType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 677 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 678) { 679 out, metadata, err = next.HandleDeserialize(ctx, in) 680 if err != nil { 681 return out, metadata, err 682 } 683 684 response, ok := out.RawResponse.(*smithyhttp.Response) 685 if !ok { 686 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 687 } 688 689 if response.StatusCode < 200 || response.StatusCode >= 300 { 690 return out, metadata, awsAwsjson10_deserializeOpErrorDeprecateWorkflowType(response, &metadata) 691 } 692 output := &DeprecateWorkflowTypeOutput{} 693 out.Result = output 694 695 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 696 return out, metadata, &smithy.DeserializationError{ 697 Err: fmt.Errorf("failed to discard response body, %w", err), 698 } 699 } 700 701 return out, metadata, err 702} 703 704func awsAwsjson10_deserializeOpErrorDeprecateWorkflowType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 705 var errorBuffer bytes.Buffer 706 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 707 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 708 } 709 errorBody := bytes.NewReader(errorBuffer.Bytes()) 710 711 errorCode := "UnknownError" 712 errorMessage := errorCode 713 714 code := response.Header.Get("X-Amzn-ErrorType") 715 if len(code) != 0 { 716 errorCode = restjson.SanitizeErrorCode(code) 717 } 718 719 var buff [1024]byte 720 ringBuffer := smithyio.NewRingBuffer(buff[:]) 721 722 body := io.TeeReader(errorBody, ringBuffer) 723 decoder := json.NewDecoder(body) 724 decoder.UseNumber() 725 code, message, err := restjson.GetErrorInfo(decoder) 726 if err != nil { 727 var snapshot bytes.Buffer 728 io.Copy(&snapshot, ringBuffer) 729 err = &smithy.DeserializationError{ 730 Err: fmt.Errorf("failed to decode response body, %w", err), 731 Snapshot: snapshot.Bytes(), 732 } 733 return err 734 } 735 736 errorBody.Seek(0, io.SeekStart) 737 if len(code) != 0 { 738 errorCode = restjson.SanitizeErrorCode(code) 739 } 740 if len(message) != 0 { 741 errorMessage = message 742 } 743 744 switch { 745 case strings.EqualFold("OperationNotPermittedFault", errorCode): 746 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 747 748 case strings.EqualFold("TypeDeprecatedFault", errorCode): 749 return awsAwsjson10_deserializeErrorTypeDeprecatedFault(response, errorBody) 750 751 case strings.EqualFold("UnknownResourceFault", errorCode): 752 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 753 754 default: 755 genericError := &smithy.GenericAPIError{ 756 Code: errorCode, 757 Message: errorMessage, 758 } 759 return genericError 760 761 } 762} 763 764type awsAwsjson10_deserializeOpDescribeActivityType struct { 765} 766 767func (*awsAwsjson10_deserializeOpDescribeActivityType) ID() string { 768 return "OperationDeserializer" 769} 770 771func (m *awsAwsjson10_deserializeOpDescribeActivityType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 772 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 773) { 774 out, metadata, err = next.HandleDeserialize(ctx, in) 775 if err != nil { 776 return out, metadata, err 777 } 778 779 response, ok := out.RawResponse.(*smithyhttp.Response) 780 if !ok { 781 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 782 } 783 784 if response.StatusCode < 200 || response.StatusCode >= 300 { 785 return out, metadata, awsAwsjson10_deserializeOpErrorDescribeActivityType(response, &metadata) 786 } 787 output := &DescribeActivityTypeOutput{} 788 out.Result = output 789 790 var buff [1024]byte 791 ringBuffer := smithyio.NewRingBuffer(buff[:]) 792 793 body := io.TeeReader(response.Body, ringBuffer) 794 decoder := json.NewDecoder(body) 795 decoder.UseNumber() 796 var shape interface{} 797 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 798 var snapshot bytes.Buffer 799 io.Copy(&snapshot, ringBuffer) 800 err = &smithy.DeserializationError{ 801 Err: fmt.Errorf("failed to decode response body, %w", err), 802 Snapshot: snapshot.Bytes(), 803 } 804 return out, metadata, err 805 } 806 807 err = awsAwsjson10_deserializeOpDocumentDescribeActivityTypeOutput(&output, shape) 808 if err != nil { 809 var snapshot bytes.Buffer 810 io.Copy(&snapshot, ringBuffer) 811 err = &smithy.DeserializationError{ 812 Err: fmt.Errorf("failed to decode response body, %w", err), 813 Snapshot: snapshot.Bytes(), 814 } 815 return out, metadata, err 816 } 817 818 return out, metadata, err 819} 820 821func awsAwsjson10_deserializeOpErrorDescribeActivityType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 822 var errorBuffer bytes.Buffer 823 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 824 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 825 } 826 errorBody := bytes.NewReader(errorBuffer.Bytes()) 827 828 errorCode := "UnknownError" 829 errorMessage := errorCode 830 831 code := response.Header.Get("X-Amzn-ErrorType") 832 if len(code) != 0 { 833 errorCode = restjson.SanitizeErrorCode(code) 834 } 835 836 var buff [1024]byte 837 ringBuffer := smithyio.NewRingBuffer(buff[:]) 838 839 body := io.TeeReader(errorBody, ringBuffer) 840 decoder := json.NewDecoder(body) 841 decoder.UseNumber() 842 code, message, err := restjson.GetErrorInfo(decoder) 843 if err != nil { 844 var snapshot bytes.Buffer 845 io.Copy(&snapshot, ringBuffer) 846 err = &smithy.DeserializationError{ 847 Err: fmt.Errorf("failed to decode response body, %w", err), 848 Snapshot: snapshot.Bytes(), 849 } 850 return err 851 } 852 853 errorBody.Seek(0, io.SeekStart) 854 if len(code) != 0 { 855 errorCode = restjson.SanitizeErrorCode(code) 856 } 857 if len(message) != 0 { 858 errorMessage = message 859 } 860 861 switch { 862 case strings.EqualFold("OperationNotPermittedFault", errorCode): 863 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 864 865 case strings.EqualFold("UnknownResourceFault", errorCode): 866 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 867 868 default: 869 genericError := &smithy.GenericAPIError{ 870 Code: errorCode, 871 Message: errorMessage, 872 } 873 return genericError 874 875 } 876} 877 878type awsAwsjson10_deserializeOpDescribeDomain struct { 879} 880 881func (*awsAwsjson10_deserializeOpDescribeDomain) ID() string { 882 return "OperationDeserializer" 883} 884 885func (m *awsAwsjson10_deserializeOpDescribeDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 886 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 887) { 888 out, metadata, err = next.HandleDeserialize(ctx, in) 889 if err != nil { 890 return out, metadata, err 891 } 892 893 response, ok := out.RawResponse.(*smithyhttp.Response) 894 if !ok { 895 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 896 } 897 898 if response.StatusCode < 200 || response.StatusCode >= 300 { 899 return out, metadata, awsAwsjson10_deserializeOpErrorDescribeDomain(response, &metadata) 900 } 901 output := &DescribeDomainOutput{} 902 out.Result = output 903 904 var buff [1024]byte 905 ringBuffer := smithyio.NewRingBuffer(buff[:]) 906 907 body := io.TeeReader(response.Body, ringBuffer) 908 decoder := json.NewDecoder(body) 909 decoder.UseNumber() 910 var shape interface{} 911 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 912 var snapshot bytes.Buffer 913 io.Copy(&snapshot, ringBuffer) 914 err = &smithy.DeserializationError{ 915 Err: fmt.Errorf("failed to decode response body, %w", err), 916 Snapshot: snapshot.Bytes(), 917 } 918 return out, metadata, err 919 } 920 921 err = awsAwsjson10_deserializeOpDocumentDescribeDomainOutput(&output, shape) 922 if err != nil { 923 var snapshot bytes.Buffer 924 io.Copy(&snapshot, ringBuffer) 925 err = &smithy.DeserializationError{ 926 Err: fmt.Errorf("failed to decode response body, %w", err), 927 Snapshot: snapshot.Bytes(), 928 } 929 return out, metadata, err 930 } 931 932 return out, metadata, err 933} 934 935func awsAwsjson10_deserializeOpErrorDescribeDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { 936 var errorBuffer bytes.Buffer 937 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 938 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 939 } 940 errorBody := bytes.NewReader(errorBuffer.Bytes()) 941 942 errorCode := "UnknownError" 943 errorMessage := errorCode 944 945 code := response.Header.Get("X-Amzn-ErrorType") 946 if len(code) != 0 { 947 errorCode = restjson.SanitizeErrorCode(code) 948 } 949 950 var buff [1024]byte 951 ringBuffer := smithyio.NewRingBuffer(buff[:]) 952 953 body := io.TeeReader(errorBody, ringBuffer) 954 decoder := json.NewDecoder(body) 955 decoder.UseNumber() 956 code, message, err := restjson.GetErrorInfo(decoder) 957 if err != nil { 958 var snapshot bytes.Buffer 959 io.Copy(&snapshot, ringBuffer) 960 err = &smithy.DeserializationError{ 961 Err: fmt.Errorf("failed to decode response body, %w", err), 962 Snapshot: snapshot.Bytes(), 963 } 964 return err 965 } 966 967 errorBody.Seek(0, io.SeekStart) 968 if len(code) != 0 { 969 errorCode = restjson.SanitizeErrorCode(code) 970 } 971 if len(message) != 0 { 972 errorMessage = message 973 } 974 975 switch { 976 case strings.EqualFold("OperationNotPermittedFault", errorCode): 977 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 978 979 case strings.EqualFold("UnknownResourceFault", errorCode): 980 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 981 982 default: 983 genericError := &smithy.GenericAPIError{ 984 Code: errorCode, 985 Message: errorMessage, 986 } 987 return genericError 988 989 } 990} 991 992type awsAwsjson10_deserializeOpDescribeWorkflowExecution struct { 993} 994 995func (*awsAwsjson10_deserializeOpDescribeWorkflowExecution) ID() string { 996 return "OperationDeserializer" 997} 998 999func (m *awsAwsjson10_deserializeOpDescribeWorkflowExecution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1000 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1001) { 1002 out, metadata, err = next.HandleDeserialize(ctx, in) 1003 if err != nil { 1004 return out, metadata, err 1005 } 1006 1007 response, ok := out.RawResponse.(*smithyhttp.Response) 1008 if !ok { 1009 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1010 } 1011 1012 if response.StatusCode < 200 || response.StatusCode >= 300 { 1013 return out, metadata, awsAwsjson10_deserializeOpErrorDescribeWorkflowExecution(response, &metadata) 1014 } 1015 output := &DescribeWorkflowExecutionOutput{} 1016 out.Result = output 1017 1018 var buff [1024]byte 1019 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1020 1021 body := io.TeeReader(response.Body, ringBuffer) 1022 decoder := json.NewDecoder(body) 1023 decoder.UseNumber() 1024 var shape interface{} 1025 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1026 var snapshot bytes.Buffer 1027 io.Copy(&snapshot, ringBuffer) 1028 err = &smithy.DeserializationError{ 1029 Err: fmt.Errorf("failed to decode response body, %w", err), 1030 Snapshot: snapshot.Bytes(), 1031 } 1032 return out, metadata, err 1033 } 1034 1035 err = awsAwsjson10_deserializeOpDocumentDescribeWorkflowExecutionOutput(&output, shape) 1036 if err != nil { 1037 var snapshot bytes.Buffer 1038 io.Copy(&snapshot, ringBuffer) 1039 err = &smithy.DeserializationError{ 1040 Err: fmt.Errorf("failed to decode response body, %w", err), 1041 Snapshot: snapshot.Bytes(), 1042 } 1043 return out, metadata, err 1044 } 1045 1046 return out, metadata, err 1047} 1048 1049func awsAwsjson10_deserializeOpErrorDescribeWorkflowExecution(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1050 var errorBuffer bytes.Buffer 1051 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1052 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1053 } 1054 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1055 1056 errorCode := "UnknownError" 1057 errorMessage := errorCode 1058 1059 code := response.Header.Get("X-Amzn-ErrorType") 1060 if len(code) != 0 { 1061 errorCode = restjson.SanitizeErrorCode(code) 1062 } 1063 1064 var buff [1024]byte 1065 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1066 1067 body := io.TeeReader(errorBody, ringBuffer) 1068 decoder := json.NewDecoder(body) 1069 decoder.UseNumber() 1070 code, message, err := restjson.GetErrorInfo(decoder) 1071 if err != nil { 1072 var snapshot bytes.Buffer 1073 io.Copy(&snapshot, ringBuffer) 1074 err = &smithy.DeserializationError{ 1075 Err: fmt.Errorf("failed to decode response body, %w", err), 1076 Snapshot: snapshot.Bytes(), 1077 } 1078 return err 1079 } 1080 1081 errorBody.Seek(0, io.SeekStart) 1082 if len(code) != 0 { 1083 errorCode = restjson.SanitizeErrorCode(code) 1084 } 1085 if len(message) != 0 { 1086 errorMessage = message 1087 } 1088 1089 switch { 1090 case strings.EqualFold("OperationNotPermittedFault", errorCode): 1091 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 1092 1093 case strings.EqualFold("UnknownResourceFault", errorCode): 1094 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 1095 1096 default: 1097 genericError := &smithy.GenericAPIError{ 1098 Code: errorCode, 1099 Message: errorMessage, 1100 } 1101 return genericError 1102 1103 } 1104} 1105 1106type awsAwsjson10_deserializeOpDescribeWorkflowType struct { 1107} 1108 1109func (*awsAwsjson10_deserializeOpDescribeWorkflowType) ID() string { 1110 return "OperationDeserializer" 1111} 1112 1113func (m *awsAwsjson10_deserializeOpDescribeWorkflowType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1114 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1115) { 1116 out, metadata, err = next.HandleDeserialize(ctx, in) 1117 if err != nil { 1118 return out, metadata, err 1119 } 1120 1121 response, ok := out.RawResponse.(*smithyhttp.Response) 1122 if !ok { 1123 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1124 } 1125 1126 if response.StatusCode < 200 || response.StatusCode >= 300 { 1127 return out, metadata, awsAwsjson10_deserializeOpErrorDescribeWorkflowType(response, &metadata) 1128 } 1129 output := &DescribeWorkflowTypeOutput{} 1130 out.Result = output 1131 1132 var buff [1024]byte 1133 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1134 1135 body := io.TeeReader(response.Body, ringBuffer) 1136 decoder := json.NewDecoder(body) 1137 decoder.UseNumber() 1138 var shape interface{} 1139 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1140 var snapshot bytes.Buffer 1141 io.Copy(&snapshot, ringBuffer) 1142 err = &smithy.DeserializationError{ 1143 Err: fmt.Errorf("failed to decode response body, %w", err), 1144 Snapshot: snapshot.Bytes(), 1145 } 1146 return out, metadata, err 1147 } 1148 1149 err = awsAwsjson10_deserializeOpDocumentDescribeWorkflowTypeOutput(&output, shape) 1150 if err != nil { 1151 var snapshot bytes.Buffer 1152 io.Copy(&snapshot, ringBuffer) 1153 err = &smithy.DeserializationError{ 1154 Err: fmt.Errorf("failed to decode response body, %w", err), 1155 Snapshot: snapshot.Bytes(), 1156 } 1157 return out, metadata, err 1158 } 1159 1160 return out, metadata, err 1161} 1162 1163func awsAwsjson10_deserializeOpErrorDescribeWorkflowType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1164 var errorBuffer bytes.Buffer 1165 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1166 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1167 } 1168 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1169 1170 errorCode := "UnknownError" 1171 errorMessage := errorCode 1172 1173 code := response.Header.Get("X-Amzn-ErrorType") 1174 if len(code) != 0 { 1175 errorCode = restjson.SanitizeErrorCode(code) 1176 } 1177 1178 var buff [1024]byte 1179 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1180 1181 body := io.TeeReader(errorBody, ringBuffer) 1182 decoder := json.NewDecoder(body) 1183 decoder.UseNumber() 1184 code, message, err := restjson.GetErrorInfo(decoder) 1185 if err != nil { 1186 var snapshot bytes.Buffer 1187 io.Copy(&snapshot, ringBuffer) 1188 err = &smithy.DeserializationError{ 1189 Err: fmt.Errorf("failed to decode response body, %w", err), 1190 Snapshot: snapshot.Bytes(), 1191 } 1192 return err 1193 } 1194 1195 errorBody.Seek(0, io.SeekStart) 1196 if len(code) != 0 { 1197 errorCode = restjson.SanitizeErrorCode(code) 1198 } 1199 if len(message) != 0 { 1200 errorMessage = message 1201 } 1202 1203 switch { 1204 case strings.EqualFold("OperationNotPermittedFault", errorCode): 1205 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 1206 1207 case strings.EqualFold("UnknownResourceFault", errorCode): 1208 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 1209 1210 default: 1211 genericError := &smithy.GenericAPIError{ 1212 Code: errorCode, 1213 Message: errorMessage, 1214 } 1215 return genericError 1216 1217 } 1218} 1219 1220type awsAwsjson10_deserializeOpGetWorkflowExecutionHistory struct { 1221} 1222 1223func (*awsAwsjson10_deserializeOpGetWorkflowExecutionHistory) ID() string { 1224 return "OperationDeserializer" 1225} 1226 1227func (m *awsAwsjson10_deserializeOpGetWorkflowExecutionHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1228 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1229) { 1230 out, metadata, err = next.HandleDeserialize(ctx, in) 1231 if err != nil { 1232 return out, metadata, err 1233 } 1234 1235 response, ok := out.RawResponse.(*smithyhttp.Response) 1236 if !ok { 1237 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1238 } 1239 1240 if response.StatusCode < 200 || response.StatusCode >= 300 { 1241 return out, metadata, awsAwsjson10_deserializeOpErrorGetWorkflowExecutionHistory(response, &metadata) 1242 } 1243 output := &GetWorkflowExecutionHistoryOutput{} 1244 out.Result = output 1245 1246 var buff [1024]byte 1247 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1248 1249 body := io.TeeReader(response.Body, ringBuffer) 1250 decoder := json.NewDecoder(body) 1251 decoder.UseNumber() 1252 var shape interface{} 1253 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1254 var snapshot bytes.Buffer 1255 io.Copy(&snapshot, ringBuffer) 1256 err = &smithy.DeserializationError{ 1257 Err: fmt.Errorf("failed to decode response body, %w", err), 1258 Snapshot: snapshot.Bytes(), 1259 } 1260 return out, metadata, err 1261 } 1262 1263 err = awsAwsjson10_deserializeOpDocumentGetWorkflowExecutionHistoryOutput(&output, shape) 1264 if err != nil { 1265 var snapshot bytes.Buffer 1266 io.Copy(&snapshot, ringBuffer) 1267 err = &smithy.DeserializationError{ 1268 Err: fmt.Errorf("failed to decode response body, %w", err), 1269 Snapshot: snapshot.Bytes(), 1270 } 1271 return out, metadata, err 1272 } 1273 1274 return out, metadata, err 1275} 1276 1277func awsAwsjson10_deserializeOpErrorGetWorkflowExecutionHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1278 var errorBuffer bytes.Buffer 1279 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1280 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1281 } 1282 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1283 1284 errorCode := "UnknownError" 1285 errorMessage := errorCode 1286 1287 code := response.Header.Get("X-Amzn-ErrorType") 1288 if len(code) != 0 { 1289 errorCode = restjson.SanitizeErrorCode(code) 1290 } 1291 1292 var buff [1024]byte 1293 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1294 1295 body := io.TeeReader(errorBody, ringBuffer) 1296 decoder := json.NewDecoder(body) 1297 decoder.UseNumber() 1298 code, message, err := restjson.GetErrorInfo(decoder) 1299 if err != nil { 1300 var snapshot bytes.Buffer 1301 io.Copy(&snapshot, ringBuffer) 1302 err = &smithy.DeserializationError{ 1303 Err: fmt.Errorf("failed to decode response body, %w", err), 1304 Snapshot: snapshot.Bytes(), 1305 } 1306 return err 1307 } 1308 1309 errorBody.Seek(0, io.SeekStart) 1310 if len(code) != 0 { 1311 errorCode = restjson.SanitizeErrorCode(code) 1312 } 1313 if len(message) != 0 { 1314 errorMessage = message 1315 } 1316 1317 switch { 1318 case strings.EqualFold("OperationNotPermittedFault", errorCode): 1319 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 1320 1321 case strings.EqualFold("UnknownResourceFault", errorCode): 1322 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 1323 1324 default: 1325 genericError := &smithy.GenericAPIError{ 1326 Code: errorCode, 1327 Message: errorMessage, 1328 } 1329 return genericError 1330 1331 } 1332} 1333 1334type awsAwsjson10_deserializeOpListActivityTypes struct { 1335} 1336 1337func (*awsAwsjson10_deserializeOpListActivityTypes) ID() string { 1338 return "OperationDeserializer" 1339} 1340 1341func (m *awsAwsjson10_deserializeOpListActivityTypes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1342 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1343) { 1344 out, metadata, err = next.HandleDeserialize(ctx, in) 1345 if err != nil { 1346 return out, metadata, err 1347 } 1348 1349 response, ok := out.RawResponse.(*smithyhttp.Response) 1350 if !ok { 1351 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1352 } 1353 1354 if response.StatusCode < 200 || response.StatusCode >= 300 { 1355 return out, metadata, awsAwsjson10_deserializeOpErrorListActivityTypes(response, &metadata) 1356 } 1357 output := &ListActivityTypesOutput{} 1358 out.Result = output 1359 1360 var buff [1024]byte 1361 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1362 1363 body := io.TeeReader(response.Body, ringBuffer) 1364 decoder := json.NewDecoder(body) 1365 decoder.UseNumber() 1366 var shape interface{} 1367 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1368 var snapshot bytes.Buffer 1369 io.Copy(&snapshot, ringBuffer) 1370 err = &smithy.DeserializationError{ 1371 Err: fmt.Errorf("failed to decode response body, %w", err), 1372 Snapshot: snapshot.Bytes(), 1373 } 1374 return out, metadata, err 1375 } 1376 1377 err = awsAwsjson10_deserializeOpDocumentListActivityTypesOutput(&output, shape) 1378 if err != nil { 1379 var snapshot bytes.Buffer 1380 io.Copy(&snapshot, ringBuffer) 1381 err = &smithy.DeserializationError{ 1382 Err: fmt.Errorf("failed to decode response body, %w", err), 1383 Snapshot: snapshot.Bytes(), 1384 } 1385 return out, metadata, err 1386 } 1387 1388 return out, metadata, err 1389} 1390 1391func awsAwsjson10_deserializeOpErrorListActivityTypes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1392 var errorBuffer bytes.Buffer 1393 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1394 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1395 } 1396 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1397 1398 errorCode := "UnknownError" 1399 errorMessage := errorCode 1400 1401 code := response.Header.Get("X-Amzn-ErrorType") 1402 if len(code) != 0 { 1403 errorCode = restjson.SanitizeErrorCode(code) 1404 } 1405 1406 var buff [1024]byte 1407 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1408 1409 body := io.TeeReader(errorBody, ringBuffer) 1410 decoder := json.NewDecoder(body) 1411 decoder.UseNumber() 1412 code, message, err := restjson.GetErrorInfo(decoder) 1413 if err != nil { 1414 var snapshot bytes.Buffer 1415 io.Copy(&snapshot, ringBuffer) 1416 err = &smithy.DeserializationError{ 1417 Err: fmt.Errorf("failed to decode response body, %w", err), 1418 Snapshot: snapshot.Bytes(), 1419 } 1420 return err 1421 } 1422 1423 errorBody.Seek(0, io.SeekStart) 1424 if len(code) != 0 { 1425 errorCode = restjson.SanitizeErrorCode(code) 1426 } 1427 if len(message) != 0 { 1428 errorMessage = message 1429 } 1430 1431 switch { 1432 case strings.EqualFold("OperationNotPermittedFault", errorCode): 1433 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 1434 1435 case strings.EqualFold("UnknownResourceFault", errorCode): 1436 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 1437 1438 default: 1439 genericError := &smithy.GenericAPIError{ 1440 Code: errorCode, 1441 Message: errorMessage, 1442 } 1443 return genericError 1444 1445 } 1446} 1447 1448type awsAwsjson10_deserializeOpListClosedWorkflowExecutions struct { 1449} 1450 1451func (*awsAwsjson10_deserializeOpListClosedWorkflowExecutions) ID() string { 1452 return "OperationDeserializer" 1453} 1454 1455func (m *awsAwsjson10_deserializeOpListClosedWorkflowExecutions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1456 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1457) { 1458 out, metadata, err = next.HandleDeserialize(ctx, in) 1459 if err != nil { 1460 return out, metadata, err 1461 } 1462 1463 response, ok := out.RawResponse.(*smithyhttp.Response) 1464 if !ok { 1465 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1466 } 1467 1468 if response.StatusCode < 200 || response.StatusCode >= 300 { 1469 return out, metadata, awsAwsjson10_deserializeOpErrorListClosedWorkflowExecutions(response, &metadata) 1470 } 1471 output := &ListClosedWorkflowExecutionsOutput{} 1472 out.Result = output 1473 1474 var buff [1024]byte 1475 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1476 1477 body := io.TeeReader(response.Body, ringBuffer) 1478 decoder := json.NewDecoder(body) 1479 decoder.UseNumber() 1480 var shape interface{} 1481 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1482 var snapshot bytes.Buffer 1483 io.Copy(&snapshot, ringBuffer) 1484 err = &smithy.DeserializationError{ 1485 Err: fmt.Errorf("failed to decode response body, %w", err), 1486 Snapshot: snapshot.Bytes(), 1487 } 1488 return out, metadata, err 1489 } 1490 1491 err = awsAwsjson10_deserializeOpDocumentListClosedWorkflowExecutionsOutput(&output, shape) 1492 if err != nil { 1493 var snapshot bytes.Buffer 1494 io.Copy(&snapshot, ringBuffer) 1495 err = &smithy.DeserializationError{ 1496 Err: fmt.Errorf("failed to decode response body, %w", err), 1497 Snapshot: snapshot.Bytes(), 1498 } 1499 return out, metadata, err 1500 } 1501 1502 return out, metadata, err 1503} 1504 1505func awsAwsjson10_deserializeOpErrorListClosedWorkflowExecutions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1506 var errorBuffer bytes.Buffer 1507 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1508 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1509 } 1510 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1511 1512 errorCode := "UnknownError" 1513 errorMessage := errorCode 1514 1515 code := response.Header.Get("X-Amzn-ErrorType") 1516 if len(code) != 0 { 1517 errorCode = restjson.SanitizeErrorCode(code) 1518 } 1519 1520 var buff [1024]byte 1521 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1522 1523 body := io.TeeReader(errorBody, ringBuffer) 1524 decoder := json.NewDecoder(body) 1525 decoder.UseNumber() 1526 code, message, err := restjson.GetErrorInfo(decoder) 1527 if err != nil { 1528 var snapshot bytes.Buffer 1529 io.Copy(&snapshot, ringBuffer) 1530 err = &smithy.DeserializationError{ 1531 Err: fmt.Errorf("failed to decode response body, %w", err), 1532 Snapshot: snapshot.Bytes(), 1533 } 1534 return err 1535 } 1536 1537 errorBody.Seek(0, io.SeekStart) 1538 if len(code) != 0 { 1539 errorCode = restjson.SanitizeErrorCode(code) 1540 } 1541 if len(message) != 0 { 1542 errorMessage = message 1543 } 1544 1545 switch { 1546 case strings.EqualFold("OperationNotPermittedFault", errorCode): 1547 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 1548 1549 case strings.EqualFold("UnknownResourceFault", errorCode): 1550 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 1551 1552 default: 1553 genericError := &smithy.GenericAPIError{ 1554 Code: errorCode, 1555 Message: errorMessage, 1556 } 1557 return genericError 1558 1559 } 1560} 1561 1562type awsAwsjson10_deserializeOpListDomains struct { 1563} 1564 1565func (*awsAwsjson10_deserializeOpListDomains) ID() string { 1566 return "OperationDeserializer" 1567} 1568 1569func (m *awsAwsjson10_deserializeOpListDomains) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1570 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1571) { 1572 out, metadata, err = next.HandleDeserialize(ctx, in) 1573 if err != nil { 1574 return out, metadata, err 1575 } 1576 1577 response, ok := out.RawResponse.(*smithyhttp.Response) 1578 if !ok { 1579 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1580 } 1581 1582 if response.StatusCode < 200 || response.StatusCode >= 300 { 1583 return out, metadata, awsAwsjson10_deserializeOpErrorListDomains(response, &metadata) 1584 } 1585 output := &ListDomainsOutput{} 1586 out.Result = output 1587 1588 var buff [1024]byte 1589 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1590 1591 body := io.TeeReader(response.Body, ringBuffer) 1592 decoder := json.NewDecoder(body) 1593 decoder.UseNumber() 1594 var shape interface{} 1595 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1596 var snapshot bytes.Buffer 1597 io.Copy(&snapshot, ringBuffer) 1598 err = &smithy.DeserializationError{ 1599 Err: fmt.Errorf("failed to decode response body, %w", err), 1600 Snapshot: snapshot.Bytes(), 1601 } 1602 return out, metadata, err 1603 } 1604 1605 err = awsAwsjson10_deserializeOpDocumentListDomainsOutput(&output, shape) 1606 if err != nil { 1607 var snapshot bytes.Buffer 1608 io.Copy(&snapshot, ringBuffer) 1609 err = &smithy.DeserializationError{ 1610 Err: fmt.Errorf("failed to decode response body, %w", err), 1611 Snapshot: snapshot.Bytes(), 1612 } 1613 return out, metadata, err 1614 } 1615 1616 return out, metadata, err 1617} 1618 1619func awsAwsjson10_deserializeOpErrorListDomains(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1620 var errorBuffer bytes.Buffer 1621 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1622 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1623 } 1624 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1625 1626 errorCode := "UnknownError" 1627 errorMessage := errorCode 1628 1629 code := response.Header.Get("X-Amzn-ErrorType") 1630 if len(code) != 0 { 1631 errorCode = restjson.SanitizeErrorCode(code) 1632 } 1633 1634 var buff [1024]byte 1635 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1636 1637 body := io.TeeReader(errorBody, ringBuffer) 1638 decoder := json.NewDecoder(body) 1639 decoder.UseNumber() 1640 code, message, err := restjson.GetErrorInfo(decoder) 1641 if err != nil { 1642 var snapshot bytes.Buffer 1643 io.Copy(&snapshot, ringBuffer) 1644 err = &smithy.DeserializationError{ 1645 Err: fmt.Errorf("failed to decode response body, %w", err), 1646 Snapshot: snapshot.Bytes(), 1647 } 1648 return err 1649 } 1650 1651 errorBody.Seek(0, io.SeekStart) 1652 if len(code) != 0 { 1653 errorCode = restjson.SanitizeErrorCode(code) 1654 } 1655 if len(message) != 0 { 1656 errorMessage = message 1657 } 1658 1659 switch { 1660 case strings.EqualFold("OperationNotPermittedFault", errorCode): 1661 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 1662 1663 default: 1664 genericError := &smithy.GenericAPIError{ 1665 Code: errorCode, 1666 Message: errorMessage, 1667 } 1668 return genericError 1669 1670 } 1671} 1672 1673type awsAwsjson10_deserializeOpListOpenWorkflowExecutions struct { 1674} 1675 1676func (*awsAwsjson10_deserializeOpListOpenWorkflowExecutions) ID() string { 1677 return "OperationDeserializer" 1678} 1679 1680func (m *awsAwsjson10_deserializeOpListOpenWorkflowExecutions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1681 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1682) { 1683 out, metadata, err = next.HandleDeserialize(ctx, in) 1684 if err != nil { 1685 return out, metadata, err 1686 } 1687 1688 response, ok := out.RawResponse.(*smithyhttp.Response) 1689 if !ok { 1690 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1691 } 1692 1693 if response.StatusCode < 200 || response.StatusCode >= 300 { 1694 return out, metadata, awsAwsjson10_deserializeOpErrorListOpenWorkflowExecutions(response, &metadata) 1695 } 1696 output := &ListOpenWorkflowExecutionsOutput{} 1697 out.Result = output 1698 1699 var buff [1024]byte 1700 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1701 1702 body := io.TeeReader(response.Body, ringBuffer) 1703 decoder := json.NewDecoder(body) 1704 decoder.UseNumber() 1705 var shape interface{} 1706 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1707 var snapshot bytes.Buffer 1708 io.Copy(&snapshot, ringBuffer) 1709 err = &smithy.DeserializationError{ 1710 Err: fmt.Errorf("failed to decode response body, %w", err), 1711 Snapshot: snapshot.Bytes(), 1712 } 1713 return out, metadata, err 1714 } 1715 1716 err = awsAwsjson10_deserializeOpDocumentListOpenWorkflowExecutionsOutput(&output, shape) 1717 if err != nil { 1718 var snapshot bytes.Buffer 1719 io.Copy(&snapshot, ringBuffer) 1720 err = &smithy.DeserializationError{ 1721 Err: fmt.Errorf("failed to decode response body, %w", err), 1722 Snapshot: snapshot.Bytes(), 1723 } 1724 return out, metadata, err 1725 } 1726 1727 return out, metadata, err 1728} 1729 1730func awsAwsjson10_deserializeOpErrorListOpenWorkflowExecutions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1731 var errorBuffer bytes.Buffer 1732 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1733 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1734 } 1735 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1736 1737 errorCode := "UnknownError" 1738 errorMessage := errorCode 1739 1740 code := response.Header.Get("X-Amzn-ErrorType") 1741 if len(code) != 0 { 1742 errorCode = restjson.SanitizeErrorCode(code) 1743 } 1744 1745 var buff [1024]byte 1746 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1747 1748 body := io.TeeReader(errorBody, ringBuffer) 1749 decoder := json.NewDecoder(body) 1750 decoder.UseNumber() 1751 code, message, err := restjson.GetErrorInfo(decoder) 1752 if err != nil { 1753 var snapshot bytes.Buffer 1754 io.Copy(&snapshot, ringBuffer) 1755 err = &smithy.DeserializationError{ 1756 Err: fmt.Errorf("failed to decode response body, %w", err), 1757 Snapshot: snapshot.Bytes(), 1758 } 1759 return err 1760 } 1761 1762 errorBody.Seek(0, io.SeekStart) 1763 if len(code) != 0 { 1764 errorCode = restjson.SanitizeErrorCode(code) 1765 } 1766 if len(message) != 0 { 1767 errorMessage = message 1768 } 1769 1770 switch { 1771 case strings.EqualFold("OperationNotPermittedFault", errorCode): 1772 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 1773 1774 case strings.EqualFold("UnknownResourceFault", errorCode): 1775 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 1776 1777 default: 1778 genericError := &smithy.GenericAPIError{ 1779 Code: errorCode, 1780 Message: errorMessage, 1781 } 1782 return genericError 1783 1784 } 1785} 1786 1787type awsAwsjson10_deserializeOpListTagsForResource struct { 1788} 1789 1790func (*awsAwsjson10_deserializeOpListTagsForResource) ID() string { 1791 return "OperationDeserializer" 1792} 1793 1794func (m *awsAwsjson10_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1795 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1796) { 1797 out, metadata, err = next.HandleDeserialize(ctx, in) 1798 if err != nil { 1799 return out, metadata, err 1800 } 1801 1802 response, ok := out.RawResponse.(*smithyhttp.Response) 1803 if !ok { 1804 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1805 } 1806 1807 if response.StatusCode < 200 || response.StatusCode >= 300 { 1808 return out, metadata, awsAwsjson10_deserializeOpErrorListTagsForResource(response, &metadata) 1809 } 1810 output := &ListTagsForResourceOutput{} 1811 out.Result = output 1812 1813 var buff [1024]byte 1814 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1815 1816 body := io.TeeReader(response.Body, ringBuffer) 1817 decoder := json.NewDecoder(body) 1818 decoder.UseNumber() 1819 var shape interface{} 1820 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1821 var snapshot bytes.Buffer 1822 io.Copy(&snapshot, ringBuffer) 1823 err = &smithy.DeserializationError{ 1824 Err: fmt.Errorf("failed to decode response body, %w", err), 1825 Snapshot: snapshot.Bytes(), 1826 } 1827 return out, metadata, err 1828 } 1829 1830 err = awsAwsjson10_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 1831 if err != nil { 1832 var snapshot bytes.Buffer 1833 io.Copy(&snapshot, ringBuffer) 1834 err = &smithy.DeserializationError{ 1835 Err: fmt.Errorf("failed to decode response body, %w", err), 1836 Snapshot: snapshot.Bytes(), 1837 } 1838 return out, metadata, err 1839 } 1840 1841 return out, metadata, err 1842} 1843 1844func awsAwsjson10_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1845 var errorBuffer bytes.Buffer 1846 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1847 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1848 } 1849 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1850 1851 errorCode := "UnknownError" 1852 errorMessage := errorCode 1853 1854 code := response.Header.Get("X-Amzn-ErrorType") 1855 if len(code) != 0 { 1856 errorCode = restjson.SanitizeErrorCode(code) 1857 } 1858 1859 var buff [1024]byte 1860 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1861 1862 body := io.TeeReader(errorBody, ringBuffer) 1863 decoder := json.NewDecoder(body) 1864 decoder.UseNumber() 1865 code, message, err := restjson.GetErrorInfo(decoder) 1866 if err != nil { 1867 var snapshot bytes.Buffer 1868 io.Copy(&snapshot, ringBuffer) 1869 err = &smithy.DeserializationError{ 1870 Err: fmt.Errorf("failed to decode response body, %w", err), 1871 Snapshot: snapshot.Bytes(), 1872 } 1873 return err 1874 } 1875 1876 errorBody.Seek(0, io.SeekStart) 1877 if len(code) != 0 { 1878 errorCode = restjson.SanitizeErrorCode(code) 1879 } 1880 if len(message) != 0 { 1881 errorMessage = message 1882 } 1883 1884 switch { 1885 case strings.EqualFold("LimitExceededFault", errorCode): 1886 return awsAwsjson10_deserializeErrorLimitExceededFault(response, errorBody) 1887 1888 case strings.EqualFold("OperationNotPermittedFault", errorCode): 1889 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 1890 1891 case strings.EqualFold("UnknownResourceFault", errorCode): 1892 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 1893 1894 default: 1895 genericError := &smithy.GenericAPIError{ 1896 Code: errorCode, 1897 Message: errorMessage, 1898 } 1899 return genericError 1900 1901 } 1902} 1903 1904type awsAwsjson10_deserializeOpListWorkflowTypes struct { 1905} 1906 1907func (*awsAwsjson10_deserializeOpListWorkflowTypes) ID() string { 1908 return "OperationDeserializer" 1909} 1910 1911func (m *awsAwsjson10_deserializeOpListWorkflowTypes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1912 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1913) { 1914 out, metadata, err = next.HandleDeserialize(ctx, in) 1915 if err != nil { 1916 return out, metadata, err 1917 } 1918 1919 response, ok := out.RawResponse.(*smithyhttp.Response) 1920 if !ok { 1921 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1922 } 1923 1924 if response.StatusCode < 200 || response.StatusCode >= 300 { 1925 return out, metadata, awsAwsjson10_deserializeOpErrorListWorkflowTypes(response, &metadata) 1926 } 1927 output := &ListWorkflowTypesOutput{} 1928 out.Result = output 1929 1930 var buff [1024]byte 1931 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1932 1933 body := io.TeeReader(response.Body, ringBuffer) 1934 decoder := json.NewDecoder(body) 1935 decoder.UseNumber() 1936 var shape interface{} 1937 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1938 var snapshot bytes.Buffer 1939 io.Copy(&snapshot, ringBuffer) 1940 err = &smithy.DeserializationError{ 1941 Err: fmt.Errorf("failed to decode response body, %w", err), 1942 Snapshot: snapshot.Bytes(), 1943 } 1944 return out, metadata, err 1945 } 1946 1947 err = awsAwsjson10_deserializeOpDocumentListWorkflowTypesOutput(&output, shape) 1948 if err != nil { 1949 var snapshot bytes.Buffer 1950 io.Copy(&snapshot, ringBuffer) 1951 err = &smithy.DeserializationError{ 1952 Err: fmt.Errorf("failed to decode response body, %w", err), 1953 Snapshot: snapshot.Bytes(), 1954 } 1955 return out, metadata, err 1956 } 1957 1958 return out, metadata, err 1959} 1960 1961func awsAwsjson10_deserializeOpErrorListWorkflowTypes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1962 var errorBuffer bytes.Buffer 1963 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1964 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1965 } 1966 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1967 1968 errorCode := "UnknownError" 1969 errorMessage := errorCode 1970 1971 code := response.Header.Get("X-Amzn-ErrorType") 1972 if len(code) != 0 { 1973 errorCode = restjson.SanitizeErrorCode(code) 1974 } 1975 1976 var buff [1024]byte 1977 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1978 1979 body := io.TeeReader(errorBody, ringBuffer) 1980 decoder := json.NewDecoder(body) 1981 decoder.UseNumber() 1982 code, message, err := restjson.GetErrorInfo(decoder) 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 err 1991 } 1992 1993 errorBody.Seek(0, io.SeekStart) 1994 if len(code) != 0 { 1995 errorCode = restjson.SanitizeErrorCode(code) 1996 } 1997 if len(message) != 0 { 1998 errorMessage = message 1999 } 2000 2001 switch { 2002 case strings.EqualFold("OperationNotPermittedFault", errorCode): 2003 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 2004 2005 case strings.EqualFold("UnknownResourceFault", errorCode): 2006 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 2007 2008 default: 2009 genericError := &smithy.GenericAPIError{ 2010 Code: errorCode, 2011 Message: errorMessage, 2012 } 2013 return genericError 2014 2015 } 2016} 2017 2018type awsAwsjson10_deserializeOpPollForActivityTask struct { 2019} 2020 2021func (*awsAwsjson10_deserializeOpPollForActivityTask) ID() string { 2022 return "OperationDeserializer" 2023} 2024 2025func (m *awsAwsjson10_deserializeOpPollForActivityTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2026 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2027) { 2028 out, metadata, err = next.HandleDeserialize(ctx, in) 2029 if err != nil { 2030 return out, metadata, err 2031 } 2032 2033 response, ok := out.RawResponse.(*smithyhttp.Response) 2034 if !ok { 2035 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2036 } 2037 2038 if response.StatusCode < 200 || response.StatusCode >= 300 { 2039 return out, metadata, awsAwsjson10_deserializeOpErrorPollForActivityTask(response, &metadata) 2040 } 2041 output := &PollForActivityTaskOutput{} 2042 out.Result = output 2043 2044 var buff [1024]byte 2045 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2046 2047 body := io.TeeReader(response.Body, ringBuffer) 2048 decoder := json.NewDecoder(body) 2049 decoder.UseNumber() 2050 var shape interface{} 2051 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2052 var snapshot bytes.Buffer 2053 io.Copy(&snapshot, ringBuffer) 2054 err = &smithy.DeserializationError{ 2055 Err: fmt.Errorf("failed to decode response body, %w", err), 2056 Snapshot: snapshot.Bytes(), 2057 } 2058 return out, metadata, err 2059 } 2060 2061 err = awsAwsjson10_deserializeOpDocumentPollForActivityTaskOutput(&output, shape) 2062 if err != nil { 2063 var snapshot bytes.Buffer 2064 io.Copy(&snapshot, ringBuffer) 2065 err = &smithy.DeserializationError{ 2066 Err: fmt.Errorf("failed to decode response body, %w", err), 2067 Snapshot: snapshot.Bytes(), 2068 } 2069 return out, metadata, err 2070 } 2071 2072 return out, metadata, err 2073} 2074 2075func awsAwsjson10_deserializeOpErrorPollForActivityTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2076 var errorBuffer bytes.Buffer 2077 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2078 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2079 } 2080 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2081 2082 errorCode := "UnknownError" 2083 errorMessage := errorCode 2084 2085 code := response.Header.Get("X-Amzn-ErrorType") 2086 if len(code) != 0 { 2087 errorCode = restjson.SanitizeErrorCode(code) 2088 } 2089 2090 var buff [1024]byte 2091 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2092 2093 body := io.TeeReader(errorBody, ringBuffer) 2094 decoder := json.NewDecoder(body) 2095 decoder.UseNumber() 2096 code, message, err := restjson.GetErrorInfo(decoder) 2097 if err != nil { 2098 var snapshot bytes.Buffer 2099 io.Copy(&snapshot, ringBuffer) 2100 err = &smithy.DeserializationError{ 2101 Err: fmt.Errorf("failed to decode response body, %w", err), 2102 Snapshot: snapshot.Bytes(), 2103 } 2104 return err 2105 } 2106 2107 errorBody.Seek(0, io.SeekStart) 2108 if len(code) != 0 { 2109 errorCode = restjson.SanitizeErrorCode(code) 2110 } 2111 if len(message) != 0 { 2112 errorMessage = message 2113 } 2114 2115 switch { 2116 case strings.EqualFold("LimitExceededFault", errorCode): 2117 return awsAwsjson10_deserializeErrorLimitExceededFault(response, errorBody) 2118 2119 case strings.EqualFold("OperationNotPermittedFault", errorCode): 2120 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 2121 2122 case strings.EqualFold("UnknownResourceFault", errorCode): 2123 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 2124 2125 default: 2126 genericError := &smithy.GenericAPIError{ 2127 Code: errorCode, 2128 Message: errorMessage, 2129 } 2130 return genericError 2131 2132 } 2133} 2134 2135type awsAwsjson10_deserializeOpPollForDecisionTask struct { 2136} 2137 2138func (*awsAwsjson10_deserializeOpPollForDecisionTask) ID() string { 2139 return "OperationDeserializer" 2140} 2141 2142func (m *awsAwsjson10_deserializeOpPollForDecisionTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2143 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2144) { 2145 out, metadata, err = next.HandleDeserialize(ctx, in) 2146 if err != nil { 2147 return out, metadata, err 2148 } 2149 2150 response, ok := out.RawResponse.(*smithyhttp.Response) 2151 if !ok { 2152 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2153 } 2154 2155 if response.StatusCode < 200 || response.StatusCode >= 300 { 2156 return out, metadata, awsAwsjson10_deserializeOpErrorPollForDecisionTask(response, &metadata) 2157 } 2158 output := &PollForDecisionTaskOutput{} 2159 out.Result = output 2160 2161 var buff [1024]byte 2162 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2163 2164 body := io.TeeReader(response.Body, ringBuffer) 2165 decoder := json.NewDecoder(body) 2166 decoder.UseNumber() 2167 var shape interface{} 2168 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2169 var snapshot bytes.Buffer 2170 io.Copy(&snapshot, ringBuffer) 2171 err = &smithy.DeserializationError{ 2172 Err: fmt.Errorf("failed to decode response body, %w", err), 2173 Snapshot: snapshot.Bytes(), 2174 } 2175 return out, metadata, err 2176 } 2177 2178 err = awsAwsjson10_deserializeOpDocumentPollForDecisionTaskOutput(&output, shape) 2179 if err != nil { 2180 var snapshot bytes.Buffer 2181 io.Copy(&snapshot, ringBuffer) 2182 err = &smithy.DeserializationError{ 2183 Err: fmt.Errorf("failed to decode response body, %w", err), 2184 Snapshot: snapshot.Bytes(), 2185 } 2186 return out, metadata, err 2187 } 2188 2189 return out, metadata, err 2190} 2191 2192func awsAwsjson10_deserializeOpErrorPollForDecisionTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2193 var errorBuffer bytes.Buffer 2194 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2195 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2196 } 2197 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2198 2199 errorCode := "UnknownError" 2200 errorMessage := errorCode 2201 2202 code := response.Header.Get("X-Amzn-ErrorType") 2203 if len(code) != 0 { 2204 errorCode = restjson.SanitizeErrorCode(code) 2205 } 2206 2207 var buff [1024]byte 2208 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2209 2210 body := io.TeeReader(errorBody, ringBuffer) 2211 decoder := json.NewDecoder(body) 2212 decoder.UseNumber() 2213 code, message, err := restjson.GetErrorInfo(decoder) 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 err 2222 } 2223 2224 errorBody.Seek(0, io.SeekStart) 2225 if len(code) != 0 { 2226 errorCode = restjson.SanitizeErrorCode(code) 2227 } 2228 if len(message) != 0 { 2229 errorMessage = message 2230 } 2231 2232 switch { 2233 case strings.EqualFold("LimitExceededFault", errorCode): 2234 return awsAwsjson10_deserializeErrorLimitExceededFault(response, errorBody) 2235 2236 case strings.EqualFold("OperationNotPermittedFault", errorCode): 2237 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 2238 2239 case strings.EqualFold("UnknownResourceFault", errorCode): 2240 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 2241 2242 default: 2243 genericError := &smithy.GenericAPIError{ 2244 Code: errorCode, 2245 Message: errorMessage, 2246 } 2247 return genericError 2248 2249 } 2250} 2251 2252type awsAwsjson10_deserializeOpRecordActivityTaskHeartbeat struct { 2253} 2254 2255func (*awsAwsjson10_deserializeOpRecordActivityTaskHeartbeat) ID() string { 2256 return "OperationDeserializer" 2257} 2258 2259func (m *awsAwsjson10_deserializeOpRecordActivityTaskHeartbeat) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2260 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2261) { 2262 out, metadata, err = next.HandleDeserialize(ctx, in) 2263 if err != nil { 2264 return out, metadata, err 2265 } 2266 2267 response, ok := out.RawResponse.(*smithyhttp.Response) 2268 if !ok { 2269 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2270 } 2271 2272 if response.StatusCode < 200 || response.StatusCode >= 300 { 2273 return out, metadata, awsAwsjson10_deserializeOpErrorRecordActivityTaskHeartbeat(response, &metadata) 2274 } 2275 output := &RecordActivityTaskHeartbeatOutput{} 2276 out.Result = output 2277 2278 var buff [1024]byte 2279 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2280 2281 body := io.TeeReader(response.Body, ringBuffer) 2282 decoder := json.NewDecoder(body) 2283 decoder.UseNumber() 2284 var shape interface{} 2285 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2286 var snapshot bytes.Buffer 2287 io.Copy(&snapshot, ringBuffer) 2288 err = &smithy.DeserializationError{ 2289 Err: fmt.Errorf("failed to decode response body, %w", err), 2290 Snapshot: snapshot.Bytes(), 2291 } 2292 return out, metadata, err 2293 } 2294 2295 err = awsAwsjson10_deserializeOpDocumentRecordActivityTaskHeartbeatOutput(&output, shape) 2296 if err != nil { 2297 var snapshot bytes.Buffer 2298 io.Copy(&snapshot, ringBuffer) 2299 err = &smithy.DeserializationError{ 2300 Err: fmt.Errorf("failed to decode response body, %w", err), 2301 Snapshot: snapshot.Bytes(), 2302 } 2303 return out, metadata, err 2304 } 2305 2306 return out, metadata, err 2307} 2308 2309func awsAwsjson10_deserializeOpErrorRecordActivityTaskHeartbeat(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2310 var errorBuffer bytes.Buffer 2311 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2312 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2313 } 2314 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2315 2316 errorCode := "UnknownError" 2317 errorMessage := errorCode 2318 2319 code := response.Header.Get("X-Amzn-ErrorType") 2320 if len(code) != 0 { 2321 errorCode = restjson.SanitizeErrorCode(code) 2322 } 2323 2324 var buff [1024]byte 2325 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2326 2327 body := io.TeeReader(errorBody, ringBuffer) 2328 decoder := json.NewDecoder(body) 2329 decoder.UseNumber() 2330 code, message, err := restjson.GetErrorInfo(decoder) 2331 if err != nil { 2332 var snapshot bytes.Buffer 2333 io.Copy(&snapshot, ringBuffer) 2334 err = &smithy.DeserializationError{ 2335 Err: fmt.Errorf("failed to decode response body, %w", err), 2336 Snapshot: snapshot.Bytes(), 2337 } 2338 return err 2339 } 2340 2341 errorBody.Seek(0, io.SeekStart) 2342 if len(code) != 0 { 2343 errorCode = restjson.SanitizeErrorCode(code) 2344 } 2345 if len(message) != 0 { 2346 errorMessage = message 2347 } 2348 2349 switch { 2350 case strings.EqualFold("OperationNotPermittedFault", errorCode): 2351 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 2352 2353 case strings.EqualFold("UnknownResourceFault", errorCode): 2354 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 2355 2356 default: 2357 genericError := &smithy.GenericAPIError{ 2358 Code: errorCode, 2359 Message: errorMessage, 2360 } 2361 return genericError 2362 2363 } 2364} 2365 2366type awsAwsjson10_deserializeOpRegisterActivityType struct { 2367} 2368 2369func (*awsAwsjson10_deserializeOpRegisterActivityType) ID() string { 2370 return "OperationDeserializer" 2371} 2372 2373func (m *awsAwsjson10_deserializeOpRegisterActivityType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2374 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2375) { 2376 out, metadata, err = next.HandleDeserialize(ctx, in) 2377 if err != nil { 2378 return out, metadata, err 2379 } 2380 2381 response, ok := out.RawResponse.(*smithyhttp.Response) 2382 if !ok { 2383 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2384 } 2385 2386 if response.StatusCode < 200 || response.StatusCode >= 300 { 2387 return out, metadata, awsAwsjson10_deserializeOpErrorRegisterActivityType(response, &metadata) 2388 } 2389 output := &RegisterActivityTypeOutput{} 2390 out.Result = output 2391 2392 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2393 return out, metadata, &smithy.DeserializationError{ 2394 Err: fmt.Errorf("failed to discard response body, %w", err), 2395 } 2396 } 2397 2398 return out, metadata, err 2399} 2400 2401func awsAwsjson10_deserializeOpErrorRegisterActivityType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2402 var errorBuffer bytes.Buffer 2403 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2404 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2405 } 2406 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2407 2408 errorCode := "UnknownError" 2409 errorMessage := errorCode 2410 2411 code := response.Header.Get("X-Amzn-ErrorType") 2412 if len(code) != 0 { 2413 errorCode = restjson.SanitizeErrorCode(code) 2414 } 2415 2416 var buff [1024]byte 2417 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2418 2419 body := io.TeeReader(errorBody, ringBuffer) 2420 decoder := json.NewDecoder(body) 2421 decoder.UseNumber() 2422 code, message, err := restjson.GetErrorInfo(decoder) 2423 if err != nil { 2424 var snapshot bytes.Buffer 2425 io.Copy(&snapshot, ringBuffer) 2426 err = &smithy.DeserializationError{ 2427 Err: fmt.Errorf("failed to decode response body, %w", err), 2428 Snapshot: snapshot.Bytes(), 2429 } 2430 return err 2431 } 2432 2433 errorBody.Seek(0, io.SeekStart) 2434 if len(code) != 0 { 2435 errorCode = restjson.SanitizeErrorCode(code) 2436 } 2437 if len(message) != 0 { 2438 errorMessage = message 2439 } 2440 2441 switch { 2442 case strings.EqualFold("LimitExceededFault", errorCode): 2443 return awsAwsjson10_deserializeErrorLimitExceededFault(response, errorBody) 2444 2445 case strings.EqualFold("OperationNotPermittedFault", errorCode): 2446 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 2447 2448 case strings.EqualFold("TypeAlreadyExistsFault", errorCode): 2449 return awsAwsjson10_deserializeErrorTypeAlreadyExistsFault(response, errorBody) 2450 2451 case strings.EqualFold("UnknownResourceFault", errorCode): 2452 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 2453 2454 default: 2455 genericError := &smithy.GenericAPIError{ 2456 Code: errorCode, 2457 Message: errorMessage, 2458 } 2459 return genericError 2460 2461 } 2462} 2463 2464type awsAwsjson10_deserializeOpRegisterDomain struct { 2465} 2466 2467func (*awsAwsjson10_deserializeOpRegisterDomain) ID() string { 2468 return "OperationDeserializer" 2469} 2470 2471func (m *awsAwsjson10_deserializeOpRegisterDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2472 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2473) { 2474 out, metadata, err = next.HandleDeserialize(ctx, in) 2475 if err != nil { 2476 return out, metadata, err 2477 } 2478 2479 response, ok := out.RawResponse.(*smithyhttp.Response) 2480 if !ok { 2481 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2482 } 2483 2484 if response.StatusCode < 200 || response.StatusCode >= 300 { 2485 return out, metadata, awsAwsjson10_deserializeOpErrorRegisterDomain(response, &metadata) 2486 } 2487 output := &RegisterDomainOutput{} 2488 out.Result = output 2489 2490 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2491 return out, metadata, &smithy.DeserializationError{ 2492 Err: fmt.Errorf("failed to discard response body, %w", err), 2493 } 2494 } 2495 2496 return out, metadata, err 2497} 2498 2499func awsAwsjson10_deserializeOpErrorRegisterDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2500 var errorBuffer bytes.Buffer 2501 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2502 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2503 } 2504 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2505 2506 errorCode := "UnknownError" 2507 errorMessage := errorCode 2508 2509 code := response.Header.Get("X-Amzn-ErrorType") 2510 if len(code) != 0 { 2511 errorCode = restjson.SanitizeErrorCode(code) 2512 } 2513 2514 var buff [1024]byte 2515 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2516 2517 body := io.TeeReader(errorBody, ringBuffer) 2518 decoder := json.NewDecoder(body) 2519 decoder.UseNumber() 2520 code, message, err := restjson.GetErrorInfo(decoder) 2521 if err != nil { 2522 var snapshot bytes.Buffer 2523 io.Copy(&snapshot, ringBuffer) 2524 err = &smithy.DeserializationError{ 2525 Err: fmt.Errorf("failed to decode response body, %w", err), 2526 Snapshot: snapshot.Bytes(), 2527 } 2528 return err 2529 } 2530 2531 errorBody.Seek(0, io.SeekStart) 2532 if len(code) != 0 { 2533 errorCode = restjson.SanitizeErrorCode(code) 2534 } 2535 if len(message) != 0 { 2536 errorMessage = message 2537 } 2538 2539 switch { 2540 case strings.EqualFold("DomainAlreadyExistsFault", errorCode): 2541 return awsAwsjson10_deserializeErrorDomainAlreadyExistsFault(response, errorBody) 2542 2543 case strings.EqualFold("LimitExceededFault", errorCode): 2544 return awsAwsjson10_deserializeErrorLimitExceededFault(response, errorBody) 2545 2546 case strings.EqualFold("OperationNotPermittedFault", errorCode): 2547 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 2548 2549 case strings.EqualFold("TooManyTagsFault", errorCode): 2550 return awsAwsjson10_deserializeErrorTooManyTagsFault(response, errorBody) 2551 2552 default: 2553 genericError := &smithy.GenericAPIError{ 2554 Code: errorCode, 2555 Message: errorMessage, 2556 } 2557 return genericError 2558 2559 } 2560} 2561 2562type awsAwsjson10_deserializeOpRegisterWorkflowType struct { 2563} 2564 2565func (*awsAwsjson10_deserializeOpRegisterWorkflowType) ID() string { 2566 return "OperationDeserializer" 2567} 2568 2569func (m *awsAwsjson10_deserializeOpRegisterWorkflowType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2570 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2571) { 2572 out, metadata, err = next.HandleDeserialize(ctx, in) 2573 if err != nil { 2574 return out, metadata, err 2575 } 2576 2577 response, ok := out.RawResponse.(*smithyhttp.Response) 2578 if !ok { 2579 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2580 } 2581 2582 if response.StatusCode < 200 || response.StatusCode >= 300 { 2583 return out, metadata, awsAwsjson10_deserializeOpErrorRegisterWorkflowType(response, &metadata) 2584 } 2585 output := &RegisterWorkflowTypeOutput{} 2586 out.Result = output 2587 2588 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2589 return out, metadata, &smithy.DeserializationError{ 2590 Err: fmt.Errorf("failed to discard response body, %w", err), 2591 } 2592 } 2593 2594 return out, metadata, err 2595} 2596 2597func awsAwsjson10_deserializeOpErrorRegisterWorkflowType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2598 var errorBuffer bytes.Buffer 2599 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2600 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2601 } 2602 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2603 2604 errorCode := "UnknownError" 2605 errorMessage := errorCode 2606 2607 code := response.Header.Get("X-Amzn-ErrorType") 2608 if len(code) != 0 { 2609 errorCode = restjson.SanitizeErrorCode(code) 2610 } 2611 2612 var buff [1024]byte 2613 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2614 2615 body := io.TeeReader(errorBody, ringBuffer) 2616 decoder := json.NewDecoder(body) 2617 decoder.UseNumber() 2618 code, message, err := restjson.GetErrorInfo(decoder) 2619 if err != nil { 2620 var snapshot bytes.Buffer 2621 io.Copy(&snapshot, ringBuffer) 2622 err = &smithy.DeserializationError{ 2623 Err: fmt.Errorf("failed to decode response body, %w", err), 2624 Snapshot: snapshot.Bytes(), 2625 } 2626 return err 2627 } 2628 2629 errorBody.Seek(0, io.SeekStart) 2630 if len(code) != 0 { 2631 errorCode = restjson.SanitizeErrorCode(code) 2632 } 2633 if len(message) != 0 { 2634 errorMessage = message 2635 } 2636 2637 switch { 2638 case strings.EqualFold("LimitExceededFault", errorCode): 2639 return awsAwsjson10_deserializeErrorLimitExceededFault(response, errorBody) 2640 2641 case strings.EqualFold("OperationNotPermittedFault", errorCode): 2642 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 2643 2644 case strings.EqualFold("TypeAlreadyExistsFault", errorCode): 2645 return awsAwsjson10_deserializeErrorTypeAlreadyExistsFault(response, errorBody) 2646 2647 case strings.EqualFold("UnknownResourceFault", errorCode): 2648 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 2649 2650 default: 2651 genericError := &smithy.GenericAPIError{ 2652 Code: errorCode, 2653 Message: errorMessage, 2654 } 2655 return genericError 2656 2657 } 2658} 2659 2660type awsAwsjson10_deserializeOpRequestCancelWorkflowExecution struct { 2661} 2662 2663func (*awsAwsjson10_deserializeOpRequestCancelWorkflowExecution) ID() string { 2664 return "OperationDeserializer" 2665} 2666 2667func (m *awsAwsjson10_deserializeOpRequestCancelWorkflowExecution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2668 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2669) { 2670 out, metadata, err = next.HandleDeserialize(ctx, in) 2671 if err != nil { 2672 return out, metadata, err 2673 } 2674 2675 response, ok := out.RawResponse.(*smithyhttp.Response) 2676 if !ok { 2677 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2678 } 2679 2680 if response.StatusCode < 200 || response.StatusCode >= 300 { 2681 return out, metadata, awsAwsjson10_deserializeOpErrorRequestCancelWorkflowExecution(response, &metadata) 2682 } 2683 output := &RequestCancelWorkflowExecutionOutput{} 2684 out.Result = output 2685 2686 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2687 return out, metadata, &smithy.DeserializationError{ 2688 Err: fmt.Errorf("failed to discard response body, %w", err), 2689 } 2690 } 2691 2692 return out, metadata, err 2693} 2694 2695func awsAwsjson10_deserializeOpErrorRequestCancelWorkflowExecution(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2696 var errorBuffer bytes.Buffer 2697 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2698 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2699 } 2700 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2701 2702 errorCode := "UnknownError" 2703 errorMessage := errorCode 2704 2705 code := response.Header.Get("X-Amzn-ErrorType") 2706 if len(code) != 0 { 2707 errorCode = restjson.SanitizeErrorCode(code) 2708 } 2709 2710 var buff [1024]byte 2711 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2712 2713 body := io.TeeReader(errorBody, ringBuffer) 2714 decoder := json.NewDecoder(body) 2715 decoder.UseNumber() 2716 code, message, err := restjson.GetErrorInfo(decoder) 2717 if err != nil { 2718 var snapshot bytes.Buffer 2719 io.Copy(&snapshot, ringBuffer) 2720 err = &smithy.DeserializationError{ 2721 Err: fmt.Errorf("failed to decode response body, %w", err), 2722 Snapshot: snapshot.Bytes(), 2723 } 2724 return err 2725 } 2726 2727 errorBody.Seek(0, io.SeekStart) 2728 if len(code) != 0 { 2729 errorCode = restjson.SanitizeErrorCode(code) 2730 } 2731 if len(message) != 0 { 2732 errorMessage = message 2733 } 2734 2735 switch { 2736 case strings.EqualFold("OperationNotPermittedFault", errorCode): 2737 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 2738 2739 case strings.EqualFold("UnknownResourceFault", errorCode): 2740 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 2741 2742 default: 2743 genericError := &smithy.GenericAPIError{ 2744 Code: errorCode, 2745 Message: errorMessage, 2746 } 2747 return genericError 2748 2749 } 2750} 2751 2752type awsAwsjson10_deserializeOpRespondActivityTaskCanceled struct { 2753} 2754 2755func (*awsAwsjson10_deserializeOpRespondActivityTaskCanceled) ID() string { 2756 return "OperationDeserializer" 2757} 2758 2759func (m *awsAwsjson10_deserializeOpRespondActivityTaskCanceled) 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, awsAwsjson10_deserializeOpErrorRespondActivityTaskCanceled(response, &metadata) 2774 } 2775 output := &RespondActivityTaskCanceledOutput{} 2776 out.Result = output 2777 2778 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2779 return out, metadata, &smithy.DeserializationError{ 2780 Err: fmt.Errorf("failed to discard response body, %w", err), 2781 } 2782 } 2783 2784 return out, metadata, err 2785} 2786 2787func awsAwsjson10_deserializeOpErrorRespondActivityTaskCanceled(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2788 var errorBuffer bytes.Buffer 2789 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2790 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2791 } 2792 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2793 2794 errorCode := "UnknownError" 2795 errorMessage := errorCode 2796 2797 code := response.Header.Get("X-Amzn-ErrorType") 2798 if len(code) != 0 { 2799 errorCode = restjson.SanitizeErrorCode(code) 2800 } 2801 2802 var buff [1024]byte 2803 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2804 2805 body := io.TeeReader(errorBody, ringBuffer) 2806 decoder := json.NewDecoder(body) 2807 decoder.UseNumber() 2808 code, message, err := restjson.GetErrorInfo(decoder) 2809 if err != nil { 2810 var snapshot bytes.Buffer 2811 io.Copy(&snapshot, ringBuffer) 2812 err = &smithy.DeserializationError{ 2813 Err: fmt.Errorf("failed to decode response body, %w", err), 2814 Snapshot: snapshot.Bytes(), 2815 } 2816 return err 2817 } 2818 2819 errorBody.Seek(0, io.SeekStart) 2820 if len(code) != 0 { 2821 errorCode = restjson.SanitizeErrorCode(code) 2822 } 2823 if len(message) != 0 { 2824 errorMessage = message 2825 } 2826 2827 switch { 2828 case strings.EqualFold("OperationNotPermittedFault", errorCode): 2829 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 2830 2831 case strings.EqualFold("UnknownResourceFault", errorCode): 2832 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 2833 2834 default: 2835 genericError := &smithy.GenericAPIError{ 2836 Code: errorCode, 2837 Message: errorMessage, 2838 } 2839 return genericError 2840 2841 } 2842} 2843 2844type awsAwsjson10_deserializeOpRespondActivityTaskCompleted struct { 2845} 2846 2847func (*awsAwsjson10_deserializeOpRespondActivityTaskCompleted) ID() string { 2848 return "OperationDeserializer" 2849} 2850 2851func (m *awsAwsjson10_deserializeOpRespondActivityTaskCompleted) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2852 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2853) { 2854 out, metadata, err = next.HandleDeserialize(ctx, in) 2855 if err != nil { 2856 return out, metadata, err 2857 } 2858 2859 response, ok := out.RawResponse.(*smithyhttp.Response) 2860 if !ok { 2861 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2862 } 2863 2864 if response.StatusCode < 200 || response.StatusCode >= 300 { 2865 return out, metadata, awsAwsjson10_deserializeOpErrorRespondActivityTaskCompleted(response, &metadata) 2866 } 2867 output := &RespondActivityTaskCompletedOutput{} 2868 out.Result = output 2869 2870 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2871 return out, metadata, &smithy.DeserializationError{ 2872 Err: fmt.Errorf("failed to discard response body, %w", err), 2873 } 2874 } 2875 2876 return out, metadata, err 2877} 2878 2879func awsAwsjson10_deserializeOpErrorRespondActivityTaskCompleted(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2880 var errorBuffer bytes.Buffer 2881 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2882 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2883 } 2884 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2885 2886 errorCode := "UnknownError" 2887 errorMessage := errorCode 2888 2889 code := response.Header.Get("X-Amzn-ErrorType") 2890 if len(code) != 0 { 2891 errorCode = restjson.SanitizeErrorCode(code) 2892 } 2893 2894 var buff [1024]byte 2895 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2896 2897 body := io.TeeReader(errorBody, ringBuffer) 2898 decoder := json.NewDecoder(body) 2899 decoder.UseNumber() 2900 code, message, err := restjson.GetErrorInfo(decoder) 2901 if err != nil { 2902 var snapshot bytes.Buffer 2903 io.Copy(&snapshot, ringBuffer) 2904 err = &smithy.DeserializationError{ 2905 Err: fmt.Errorf("failed to decode response body, %w", err), 2906 Snapshot: snapshot.Bytes(), 2907 } 2908 return err 2909 } 2910 2911 errorBody.Seek(0, io.SeekStart) 2912 if len(code) != 0 { 2913 errorCode = restjson.SanitizeErrorCode(code) 2914 } 2915 if len(message) != 0 { 2916 errorMessage = message 2917 } 2918 2919 switch { 2920 case strings.EqualFold("OperationNotPermittedFault", errorCode): 2921 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 2922 2923 case strings.EqualFold("UnknownResourceFault", errorCode): 2924 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 2925 2926 default: 2927 genericError := &smithy.GenericAPIError{ 2928 Code: errorCode, 2929 Message: errorMessage, 2930 } 2931 return genericError 2932 2933 } 2934} 2935 2936type awsAwsjson10_deserializeOpRespondActivityTaskFailed struct { 2937} 2938 2939func (*awsAwsjson10_deserializeOpRespondActivityTaskFailed) ID() string { 2940 return "OperationDeserializer" 2941} 2942 2943func (m *awsAwsjson10_deserializeOpRespondActivityTaskFailed) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2944 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2945) { 2946 out, metadata, err = next.HandleDeserialize(ctx, in) 2947 if err != nil { 2948 return out, metadata, err 2949 } 2950 2951 response, ok := out.RawResponse.(*smithyhttp.Response) 2952 if !ok { 2953 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2954 } 2955 2956 if response.StatusCode < 200 || response.StatusCode >= 300 { 2957 return out, metadata, awsAwsjson10_deserializeOpErrorRespondActivityTaskFailed(response, &metadata) 2958 } 2959 output := &RespondActivityTaskFailedOutput{} 2960 out.Result = output 2961 2962 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2963 return out, metadata, &smithy.DeserializationError{ 2964 Err: fmt.Errorf("failed to discard response body, %w", err), 2965 } 2966 } 2967 2968 return out, metadata, err 2969} 2970 2971func awsAwsjson10_deserializeOpErrorRespondActivityTaskFailed(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2972 var errorBuffer bytes.Buffer 2973 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2974 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2975 } 2976 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2977 2978 errorCode := "UnknownError" 2979 errorMessage := errorCode 2980 2981 code := response.Header.Get("X-Amzn-ErrorType") 2982 if len(code) != 0 { 2983 errorCode = restjson.SanitizeErrorCode(code) 2984 } 2985 2986 var buff [1024]byte 2987 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2988 2989 body := io.TeeReader(errorBody, ringBuffer) 2990 decoder := json.NewDecoder(body) 2991 decoder.UseNumber() 2992 code, message, err := restjson.GetErrorInfo(decoder) 2993 if err != nil { 2994 var snapshot bytes.Buffer 2995 io.Copy(&snapshot, ringBuffer) 2996 err = &smithy.DeserializationError{ 2997 Err: fmt.Errorf("failed to decode response body, %w", err), 2998 Snapshot: snapshot.Bytes(), 2999 } 3000 return err 3001 } 3002 3003 errorBody.Seek(0, io.SeekStart) 3004 if len(code) != 0 { 3005 errorCode = restjson.SanitizeErrorCode(code) 3006 } 3007 if len(message) != 0 { 3008 errorMessage = message 3009 } 3010 3011 switch { 3012 case strings.EqualFold("OperationNotPermittedFault", errorCode): 3013 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 3014 3015 case strings.EqualFold("UnknownResourceFault", errorCode): 3016 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 3017 3018 default: 3019 genericError := &smithy.GenericAPIError{ 3020 Code: errorCode, 3021 Message: errorMessage, 3022 } 3023 return genericError 3024 3025 } 3026} 3027 3028type awsAwsjson10_deserializeOpRespondDecisionTaskCompleted struct { 3029} 3030 3031func (*awsAwsjson10_deserializeOpRespondDecisionTaskCompleted) ID() string { 3032 return "OperationDeserializer" 3033} 3034 3035func (m *awsAwsjson10_deserializeOpRespondDecisionTaskCompleted) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3036 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3037) { 3038 out, metadata, err = next.HandleDeserialize(ctx, in) 3039 if err != nil { 3040 return out, metadata, err 3041 } 3042 3043 response, ok := out.RawResponse.(*smithyhttp.Response) 3044 if !ok { 3045 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3046 } 3047 3048 if response.StatusCode < 200 || response.StatusCode >= 300 { 3049 return out, metadata, awsAwsjson10_deserializeOpErrorRespondDecisionTaskCompleted(response, &metadata) 3050 } 3051 output := &RespondDecisionTaskCompletedOutput{} 3052 out.Result = output 3053 3054 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3055 return out, metadata, &smithy.DeserializationError{ 3056 Err: fmt.Errorf("failed to discard response body, %w", err), 3057 } 3058 } 3059 3060 return out, metadata, err 3061} 3062 3063func awsAwsjson10_deserializeOpErrorRespondDecisionTaskCompleted(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3064 var errorBuffer bytes.Buffer 3065 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3066 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3067 } 3068 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3069 3070 errorCode := "UnknownError" 3071 errorMessage := errorCode 3072 3073 code := response.Header.Get("X-Amzn-ErrorType") 3074 if len(code) != 0 { 3075 errorCode = restjson.SanitizeErrorCode(code) 3076 } 3077 3078 var buff [1024]byte 3079 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3080 3081 body := io.TeeReader(errorBody, ringBuffer) 3082 decoder := json.NewDecoder(body) 3083 decoder.UseNumber() 3084 code, message, err := restjson.GetErrorInfo(decoder) 3085 if err != nil { 3086 var snapshot bytes.Buffer 3087 io.Copy(&snapshot, ringBuffer) 3088 err = &smithy.DeserializationError{ 3089 Err: fmt.Errorf("failed to decode response body, %w", err), 3090 Snapshot: snapshot.Bytes(), 3091 } 3092 return err 3093 } 3094 3095 errorBody.Seek(0, io.SeekStart) 3096 if len(code) != 0 { 3097 errorCode = restjson.SanitizeErrorCode(code) 3098 } 3099 if len(message) != 0 { 3100 errorMessage = message 3101 } 3102 3103 switch { 3104 case strings.EqualFold("OperationNotPermittedFault", errorCode): 3105 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 3106 3107 case strings.EqualFold("UnknownResourceFault", errorCode): 3108 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 3109 3110 default: 3111 genericError := &smithy.GenericAPIError{ 3112 Code: errorCode, 3113 Message: errorMessage, 3114 } 3115 return genericError 3116 3117 } 3118} 3119 3120type awsAwsjson10_deserializeOpSignalWorkflowExecution struct { 3121} 3122 3123func (*awsAwsjson10_deserializeOpSignalWorkflowExecution) ID() string { 3124 return "OperationDeserializer" 3125} 3126 3127func (m *awsAwsjson10_deserializeOpSignalWorkflowExecution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3128 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3129) { 3130 out, metadata, err = next.HandleDeserialize(ctx, in) 3131 if err != nil { 3132 return out, metadata, err 3133 } 3134 3135 response, ok := out.RawResponse.(*smithyhttp.Response) 3136 if !ok { 3137 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3138 } 3139 3140 if response.StatusCode < 200 || response.StatusCode >= 300 { 3141 return out, metadata, awsAwsjson10_deserializeOpErrorSignalWorkflowExecution(response, &metadata) 3142 } 3143 output := &SignalWorkflowExecutionOutput{} 3144 out.Result = output 3145 3146 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3147 return out, metadata, &smithy.DeserializationError{ 3148 Err: fmt.Errorf("failed to discard response body, %w", err), 3149 } 3150 } 3151 3152 return out, metadata, err 3153} 3154 3155func awsAwsjson10_deserializeOpErrorSignalWorkflowExecution(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3156 var errorBuffer bytes.Buffer 3157 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3158 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3159 } 3160 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3161 3162 errorCode := "UnknownError" 3163 errorMessage := errorCode 3164 3165 code := response.Header.Get("X-Amzn-ErrorType") 3166 if len(code) != 0 { 3167 errorCode = restjson.SanitizeErrorCode(code) 3168 } 3169 3170 var buff [1024]byte 3171 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3172 3173 body := io.TeeReader(errorBody, ringBuffer) 3174 decoder := json.NewDecoder(body) 3175 decoder.UseNumber() 3176 code, message, err := restjson.GetErrorInfo(decoder) 3177 if err != nil { 3178 var snapshot bytes.Buffer 3179 io.Copy(&snapshot, ringBuffer) 3180 err = &smithy.DeserializationError{ 3181 Err: fmt.Errorf("failed to decode response body, %w", err), 3182 Snapshot: snapshot.Bytes(), 3183 } 3184 return err 3185 } 3186 3187 errorBody.Seek(0, io.SeekStart) 3188 if len(code) != 0 { 3189 errorCode = restjson.SanitizeErrorCode(code) 3190 } 3191 if len(message) != 0 { 3192 errorMessage = message 3193 } 3194 3195 switch { 3196 case strings.EqualFold("OperationNotPermittedFault", errorCode): 3197 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 3198 3199 case strings.EqualFold("UnknownResourceFault", errorCode): 3200 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 3201 3202 default: 3203 genericError := &smithy.GenericAPIError{ 3204 Code: errorCode, 3205 Message: errorMessage, 3206 } 3207 return genericError 3208 3209 } 3210} 3211 3212type awsAwsjson10_deserializeOpStartWorkflowExecution struct { 3213} 3214 3215func (*awsAwsjson10_deserializeOpStartWorkflowExecution) ID() string { 3216 return "OperationDeserializer" 3217} 3218 3219func (m *awsAwsjson10_deserializeOpStartWorkflowExecution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3220 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3221) { 3222 out, metadata, err = next.HandleDeserialize(ctx, in) 3223 if err != nil { 3224 return out, metadata, err 3225 } 3226 3227 response, ok := out.RawResponse.(*smithyhttp.Response) 3228 if !ok { 3229 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3230 } 3231 3232 if response.StatusCode < 200 || response.StatusCode >= 300 { 3233 return out, metadata, awsAwsjson10_deserializeOpErrorStartWorkflowExecution(response, &metadata) 3234 } 3235 output := &StartWorkflowExecutionOutput{} 3236 out.Result = output 3237 3238 var buff [1024]byte 3239 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3240 3241 body := io.TeeReader(response.Body, ringBuffer) 3242 decoder := json.NewDecoder(body) 3243 decoder.UseNumber() 3244 var shape interface{} 3245 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3246 var snapshot bytes.Buffer 3247 io.Copy(&snapshot, ringBuffer) 3248 err = &smithy.DeserializationError{ 3249 Err: fmt.Errorf("failed to decode response body, %w", err), 3250 Snapshot: snapshot.Bytes(), 3251 } 3252 return out, metadata, err 3253 } 3254 3255 err = awsAwsjson10_deserializeOpDocumentStartWorkflowExecutionOutput(&output, shape) 3256 if err != nil { 3257 var snapshot bytes.Buffer 3258 io.Copy(&snapshot, ringBuffer) 3259 err = &smithy.DeserializationError{ 3260 Err: fmt.Errorf("failed to decode response body, %w", err), 3261 Snapshot: snapshot.Bytes(), 3262 } 3263 return out, metadata, err 3264 } 3265 3266 return out, metadata, err 3267} 3268 3269func awsAwsjson10_deserializeOpErrorStartWorkflowExecution(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3270 var errorBuffer bytes.Buffer 3271 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3272 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3273 } 3274 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3275 3276 errorCode := "UnknownError" 3277 errorMessage := errorCode 3278 3279 code := response.Header.Get("X-Amzn-ErrorType") 3280 if len(code) != 0 { 3281 errorCode = restjson.SanitizeErrorCode(code) 3282 } 3283 3284 var buff [1024]byte 3285 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3286 3287 body := io.TeeReader(errorBody, ringBuffer) 3288 decoder := json.NewDecoder(body) 3289 decoder.UseNumber() 3290 code, message, err := restjson.GetErrorInfo(decoder) 3291 if err != nil { 3292 var snapshot bytes.Buffer 3293 io.Copy(&snapshot, ringBuffer) 3294 err = &smithy.DeserializationError{ 3295 Err: fmt.Errorf("failed to decode response body, %w", err), 3296 Snapshot: snapshot.Bytes(), 3297 } 3298 return err 3299 } 3300 3301 errorBody.Seek(0, io.SeekStart) 3302 if len(code) != 0 { 3303 errorCode = restjson.SanitizeErrorCode(code) 3304 } 3305 if len(message) != 0 { 3306 errorMessage = message 3307 } 3308 3309 switch { 3310 case strings.EqualFold("DefaultUndefinedFault", errorCode): 3311 return awsAwsjson10_deserializeErrorDefaultUndefinedFault(response, errorBody) 3312 3313 case strings.EqualFold("LimitExceededFault", errorCode): 3314 return awsAwsjson10_deserializeErrorLimitExceededFault(response, errorBody) 3315 3316 case strings.EqualFold("OperationNotPermittedFault", errorCode): 3317 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 3318 3319 case strings.EqualFold("TypeDeprecatedFault", errorCode): 3320 return awsAwsjson10_deserializeErrorTypeDeprecatedFault(response, errorBody) 3321 3322 case strings.EqualFold("UnknownResourceFault", errorCode): 3323 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 3324 3325 case strings.EqualFold("WorkflowExecutionAlreadyStartedFault", errorCode): 3326 return awsAwsjson10_deserializeErrorWorkflowExecutionAlreadyStartedFault(response, errorBody) 3327 3328 default: 3329 genericError := &smithy.GenericAPIError{ 3330 Code: errorCode, 3331 Message: errorMessage, 3332 } 3333 return genericError 3334 3335 } 3336} 3337 3338type awsAwsjson10_deserializeOpTagResource struct { 3339} 3340 3341func (*awsAwsjson10_deserializeOpTagResource) ID() string { 3342 return "OperationDeserializer" 3343} 3344 3345func (m *awsAwsjson10_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3346 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3347) { 3348 out, metadata, err = next.HandleDeserialize(ctx, in) 3349 if err != nil { 3350 return out, metadata, err 3351 } 3352 3353 response, ok := out.RawResponse.(*smithyhttp.Response) 3354 if !ok { 3355 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3356 } 3357 3358 if response.StatusCode < 200 || response.StatusCode >= 300 { 3359 return out, metadata, awsAwsjson10_deserializeOpErrorTagResource(response, &metadata) 3360 } 3361 output := &TagResourceOutput{} 3362 out.Result = output 3363 3364 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3365 return out, metadata, &smithy.DeserializationError{ 3366 Err: fmt.Errorf("failed to discard response body, %w", err), 3367 } 3368 } 3369 3370 return out, metadata, err 3371} 3372 3373func awsAwsjson10_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3374 var errorBuffer bytes.Buffer 3375 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3376 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3377 } 3378 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3379 3380 errorCode := "UnknownError" 3381 errorMessage := errorCode 3382 3383 code := response.Header.Get("X-Amzn-ErrorType") 3384 if len(code) != 0 { 3385 errorCode = restjson.SanitizeErrorCode(code) 3386 } 3387 3388 var buff [1024]byte 3389 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3390 3391 body := io.TeeReader(errorBody, ringBuffer) 3392 decoder := json.NewDecoder(body) 3393 decoder.UseNumber() 3394 code, message, err := restjson.GetErrorInfo(decoder) 3395 if err != nil { 3396 var snapshot bytes.Buffer 3397 io.Copy(&snapshot, ringBuffer) 3398 err = &smithy.DeserializationError{ 3399 Err: fmt.Errorf("failed to decode response body, %w", err), 3400 Snapshot: snapshot.Bytes(), 3401 } 3402 return err 3403 } 3404 3405 errorBody.Seek(0, io.SeekStart) 3406 if len(code) != 0 { 3407 errorCode = restjson.SanitizeErrorCode(code) 3408 } 3409 if len(message) != 0 { 3410 errorMessage = message 3411 } 3412 3413 switch { 3414 case strings.EqualFold("LimitExceededFault", errorCode): 3415 return awsAwsjson10_deserializeErrorLimitExceededFault(response, errorBody) 3416 3417 case strings.EqualFold("OperationNotPermittedFault", errorCode): 3418 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 3419 3420 case strings.EqualFold("TooManyTagsFault", errorCode): 3421 return awsAwsjson10_deserializeErrorTooManyTagsFault(response, errorBody) 3422 3423 case strings.EqualFold("UnknownResourceFault", errorCode): 3424 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 3425 3426 default: 3427 genericError := &smithy.GenericAPIError{ 3428 Code: errorCode, 3429 Message: errorMessage, 3430 } 3431 return genericError 3432 3433 } 3434} 3435 3436type awsAwsjson10_deserializeOpTerminateWorkflowExecution struct { 3437} 3438 3439func (*awsAwsjson10_deserializeOpTerminateWorkflowExecution) ID() string { 3440 return "OperationDeserializer" 3441} 3442 3443func (m *awsAwsjson10_deserializeOpTerminateWorkflowExecution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3444 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3445) { 3446 out, metadata, err = next.HandleDeserialize(ctx, in) 3447 if err != nil { 3448 return out, metadata, err 3449 } 3450 3451 response, ok := out.RawResponse.(*smithyhttp.Response) 3452 if !ok { 3453 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3454 } 3455 3456 if response.StatusCode < 200 || response.StatusCode >= 300 { 3457 return out, metadata, awsAwsjson10_deserializeOpErrorTerminateWorkflowExecution(response, &metadata) 3458 } 3459 output := &TerminateWorkflowExecutionOutput{} 3460 out.Result = output 3461 3462 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3463 return out, metadata, &smithy.DeserializationError{ 3464 Err: fmt.Errorf("failed to discard response body, %w", err), 3465 } 3466 } 3467 3468 return out, metadata, err 3469} 3470 3471func awsAwsjson10_deserializeOpErrorTerminateWorkflowExecution(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3472 var errorBuffer bytes.Buffer 3473 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3474 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3475 } 3476 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3477 3478 errorCode := "UnknownError" 3479 errorMessage := errorCode 3480 3481 code := response.Header.Get("X-Amzn-ErrorType") 3482 if len(code) != 0 { 3483 errorCode = restjson.SanitizeErrorCode(code) 3484 } 3485 3486 var buff [1024]byte 3487 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3488 3489 body := io.TeeReader(errorBody, ringBuffer) 3490 decoder := json.NewDecoder(body) 3491 decoder.UseNumber() 3492 code, message, err := restjson.GetErrorInfo(decoder) 3493 if err != nil { 3494 var snapshot bytes.Buffer 3495 io.Copy(&snapshot, ringBuffer) 3496 err = &smithy.DeserializationError{ 3497 Err: fmt.Errorf("failed to decode response body, %w", err), 3498 Snapshot: snapshot.Bytes(), 3499 } 3500 return err 3501 } 3502 3503 errorBody.Seek(0, io.SeekStart) 3504 if len(code) != 0 { 3505 errorCode = restjson.SanitizeErrorCode(code) 3506 } 3507 if len(message) != 0 { 3508 errorMessage = message 3509 } 3510 3511 switch { 3512 case strings.EqualFold("OperationNotPermittedFault", errorCode): 3513 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 3514 3515 case strings.EqualFold("UnknownResourceFault", errorCode): 3516 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 3517 3518 default: 3519 genericError := &smithy.GenericAPIError{ 3520 Code: errorCode, 3521 Message: errorMessage, 3522 } 3523 return genericError 3524 3525 } 3526} 3527 3528type awsAwsjson10_deserializeOpUndeprecateActivityType struct { 3529} 3530 3531func (*awsAwsjson10_deserializeOpUndeprecateActivityType) ID() string { 3532 return "OperationDeserializer" 3533} 3534 3535func (m *awsAwsjson10_deserializeOpUndeprecateActivityType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3536 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3537) { 3538 out, metadata, err = next.HandleDeserialize(ctx, in) 3539 if err != nil { 3540 return out, metadata, err 3541 } 3542 3543 response, ok := out.RawResponse.(*smithyhttp.Response) 3544 if !ok { 3545 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3546 } 3547 3548 if response.StatusCode < 200 || response.StatusCode >= 300 { 3549 return out, metadata, awsAwsjson10_deserializeOpErrorUndeprecateActivityType(response, &metadata) 3550 } 3551 output := &UndeprecateActivityTypeOutput{} 3552 out.Result = output 3553 3554 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3555 return out, metadata, &smithy.DeserializationError{ 3556 Err: fmt.Errorf("failed to discard response body, %w", err), 3557 } 3558 } 3559 3560 return out, metadata, err 3561} 3562 3563func awsAwsjson10_deserializeOpErrorUndeprecateActivityType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3564 var errorBuffer bytes.Buffer 3565 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3566 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3567 } 3568 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3569 3570 errorCode := "UnknownError" 3571 errorMessage := errorCode 3572 3573 code := response.Header.Get("X-Amzn-ErrorType") 3574 if len(code) != 0 { 3575 errorCode = restjson.SanitizeErrorCode(code) 3576 } 3577 3578 var buff [1024]byte 3579 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3580 3581 body := io.TeeReader(errorBody, ringBuffer) 3582 decoder := json.NewDecoder(body) 3583 decoder.UseNumber() 3584 code, message, err := restjson.GetErrorInfo(decoder) 3585 if err != nil { 3586 var snapshot bytes.Buffer 3587 io.Copy(&snapshot, ringBuffer) 3588 err = &smithy.DeserializationError{ 3589 Err: fmt.Errorf("failed to decode response body, %w", err), 3590 Snapshot: snapshot.Bytes(), 3591 } 3592 return err 3593 } 3594 3595 errorBody.Seek(0, io.SeekStart) 3596 if len(code) != 0 { 3597 errorCode = restjson.SanitizeErrorCode(code) 3598 } 3599 if len(message) != 0 { 3600 errorMessage = message 3601 } 3602 3603 switch { 3604 case strings.EqualFold("OperationNotPermittedFault", errorCode): 3605 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 3606 3607 case strings.EqualFold("TypeAlreadyExistsFault", errorCode): 3608 return awsAwsjson10_deserializeErrorTypeAlreadyExistsFault(response, errorBody) 3609 3610 case strings.EqualFold("UnknownResourceFault", errorCode): 3611 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 3612 3613 default: 3614 genericError := &smithy.GenericAPIError{ 3615 Code: errorCode, 3616 Message: errorMessage, 3617 } 3618 return genericError 3619 3620 } 3621} 3622 3623type awsAwsjson10_deserializeOpUndeprecateDomain struct { 3624} 3625 3626func (*awsAwsjson10_deserializeOpUndeprecateDomain) ID() string { 3627 return "OperationDeserializer" 3628} 3629 3630func (m *awsAwsjson10_deserializeOpUndeprecateDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3631 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3632) { 3633 out, metadata, err = next.HandleDeserialize(ctx, in) 3634 if err != nil { 3635 return out, metadata, err 3636 } 3637 3638 response, ok := out.RawResponse.(*smithyhttp.Response) 3639 if !ok { 3640 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3641 } 3642 3643 if response.StatusCode < 200 || response.StatusCode >= 300 { 3644 return out, metadata, awsAwsjson10_deserializeOpErrorUndeprecateDomain(response, &metadata) 3645 } 3646 output := &UndeprecateDomainOutput{} 3647 out.Result = output 3648 3649 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3650 return out, metadata, &smithy.DeserializationError{ 3651 Err: fmt.Errorf("failed to discard response body, %w", err), 3652 } 3653 } 3654 3655 return out, metadata, err 3656} 3657 3658func awsAwsjson10_deserializeOpErrorUndeprecateDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3659 var errorBuffer bytes.Buffer 3660 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3661 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3662 } 3663 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3664 3665 errorCode := "UnknownError" 3666 errorMessage := errorCode 3667 3668 code := response.Header.Get("X-Amzn-ErrorType") 3669 if len(code) != 0 { 3670 errorCode = restjson.SanitizeErrorCode(code) 3671 } 3672 3673 var buff [1024]byte 3674 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3675 3676 body := io.TeeReader(errorBody, ringBuffer) 3677 decoder := json.NewDecoder(body) 3678 decoder.UseNumber() 3679 code, message, err := restjson.GetErrorInfo(decoder) 3680 if err != nil { 3681 var snapshot bytes.Buffer 3682 io.Copy(&snapshot, ringBuffer) 3683 err = &smithy.DeserializationError{ 3684 Err: fmt.Errorf("failed to decode response body, %w", err), 3685 Snapshot: snapshot.Bytes(), 3686 } 3687 return err 3688 } 3689 3690 errorBody.Seek(0, io.SeekStart) 3691 if len(code) != 0 { 3692 errorCode = restjson.SanitizeErrorCode(code) 3693 } 3694 if len(message) != 0 { 3695 errorMessage = message 3696 } 3697 3698 switch { 3699 case strings.EqualFold("DomainAlreadyExistsFault", errorCode): 3700 return awsAwsjson10_deserializeErrorDomainAlreadyExistsFault(response, errorBody) 3701 3702 case strings.EqualFold("OperationNotPermittedFault", errorCode): 3703 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 3704 3705 case strings.EqualFold("UnknownResourceFault", errorCode): 3706 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 3707 3708 default: 3709 genericError := &smithy.GenericAPIError{ 3710 Code: errorCode, 3711 Message: errorMessage, 3712 } 3713 return genericError 3714 3715 } 3716} 3717 3718type awsAwsjson10_deserializeOpUndeprecateWorkflowType struct { 3719} 3720 3721func (*awsAwsjson10_deserializeOpUndeprecateWorkflowType) ID() string { 3722 return "OperationDeserializer" 3723} 3724 3725func (m *awsAwsjson10_deserializeOpUndeprecateWorkflowType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3726 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3727) { 3728 out, metadata, err = next.HandleDeserialize(ctx, in) 3729 if err != nil { 3730 return out, metadata, err 3731 } 3732 3733 response, ok := out.RawResponse.(*smithyhttp.Response) 3734 if !ok { 3735 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3736 } 3737 3738 if response.StatusCode < 200 || response.StatusCode >= 300 { 3739 return out, metadata, awsAwsjson10_deserializeOpErrorUndeprecateWorkflowType(response, &metadata) 3740 } 3741 output := &UndeprecateWorkflowTypeOutput{} 3742 out.Result = output 3743 3744 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3745 return out, metadata, &smithy.DeserializationError{ 3746 Err: fmt.Errorf("failed to discard response body, %w", err), 3747 } 3748 } 3749 3750 return out, metadata, err 3751} 3752 3753func awsAwsjson10_deserializeOpErrorUndeprecateWorkflowType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3754 var errorBuffer bytes.Buffer 3755 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3756 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3757 } 3758 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3759 3760 errorCode := "UnknownError" 3761 errorMessage := errorCode 3762 3763 code := response.Header.Get("X-Amzn-ErrorType") 3764 if len(code) != 0 { 3765 errorCode = restjson.SanitizeErrorCode(code) 3766 } 3767 3768 var buff [1024]byte 3769 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3770 3771 body := io.TeeReader(errorBody, ringBuffer) 3772 decoder := json.NewDecoder(body) 3773 decoder.UseNumber() 3774 code, message, err := restjson.GetErrorInfo(decoder) 3775 if err != nil { 3776 var snapshot bytes.Buffer 3777 io.Copy(&snapshot, ringBuffer) 3778 err = &smithy.DeserializationError{ 3779 Err: fmt.Errorf("failed to decode response body, %w", err), 3780 Snapshot: snapshot.Bytes(), 3781 } 3782 return err 3783 } 3784 3785 errorBody.Seek(0, io.SeekStart) 3786 if len(code) != 0 { 3787 errorCode = restjson.SanitizeErrorCode(code) 3788 } 3789 if len(message) != 0 { 3790 errorMessage = message 3791 } 3792 3793 switch { 3794 case strings.EqualFold("OperationNotPermittedFault", errorCode): 3795 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 3796 3797 case strings.EqualFold("TypeAlreadyExistsFault", errorCode): 3798 return awsAwsjson10_deserializeErrorTypeAlreadyExistsFault(response, errorBody) 3799 3800 case strings.EqualFold("UnknownResourceFault", errorCode): 3801 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 3802 3803 default: 3804 genericError := &smithy.GenericAPIError{ 3805 Code: errorCode, 3806 Message: errorMessage, 3807 } 3808 return genericError 3809 3810 } 3811} 3812 3813type awsAwsjson10_deserializeOpUntagResource struct { 3814} 3815 3816func (*awsAwsjson10_deserializeOpUntagResource) ID() string { 3817 return "OperationDeserializer" 3818} 3819 3820func (m *awsAwsjson10_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3821 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3822) { 3823 out, metadata, err = next.HandleDeserialize(ctx, in) 3824 if err != nil { 3825 return out, metadata, err 3826 } 3827 3828 response, ok := out.RawResponse.(*smithyhttp.Response) 3829 if !ok { 3830 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3831 } 3832 3833 if response.StatusCode < 200 || response.StatusCode >= 300 { 3834 return out, metadata, awsAwsjson10_deserializeOpErrorUntagResource(response, &metadata) 3835 } 3836 output := &UntagResourceOutput{} 3837 out.Result = output 3838 3839 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3840 return out, metadata, &smithy.DeserializationError{ 3841 Err: fmt.Errorf("failed to discard response body, %w", err), 3842 } 3843 } 3844 3845 return out, metadata, err 3846} 3847 3848func awsAwsjson10_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3849 var errorBuffer bytes.Buffer 3850 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3851 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3852 } 3853 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3854 3855 errorCode := "UnknownError" 3856 errorMessage := errorCode 3857 3858 code := response.Header.Get("X-Amzn-ErrorType") 3859 if len(code) != 0 { 3860 errorCode = restjson.SanitizeErrorCode(code) 3861 } 3862 3863 var buff [1024]byte 3864 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3865 3866 body := io.TeeReader(errorBody, ringBuffer) 3867 decoder := json.NewDecoder(body) 3868 decoder.UseNumber() 3869 code, message, err := restjson.GetErrorInfo(decoder) 3870 if err != nil { 3871 var snapshot bytes.Buffer 3872 io.Copy(&snapshot, ringBuffer) 3873 err = &smithy.DeserializationError{ 3874 Err: fmt.Errorf("failed to decode response body, %w", err), 3875 Snapshot: snapshot.Bytes(), 3876 } 3877 return err 3878 } 3879 3880 errorBody.Seek(0, io.SeekStart) 3881 if len(code) != 0 { 3882 errorCode = restjson.SanitizeErrorCode(code) 3883 } 3884 if len(message) != 0 { 3885 errorMessage = message 3886 } 3887 3888 switch { 3889 case strings.EqualFold("LimitExceededFault", errorCode): 3890 return awsAwsjson10_deserializeErrorLimitExceededFault(response, errorBody) 3891 3892 case strings.EqualFold("OperationNotPermittedFault", errorCode): 3893 return awsAwsjson10_deserializeErrorOperationNotPermittedFault(response, errorBody) 3894 3895 case strings.EqualFold("UnknownResourceFault", errorCode): 3896 return awsAwsjson10_deserializeErrorUnknownResourceFault(response, errorBody) 3897 3898 default: 3899 genericError := &smithy.GenericAPIError{ 3900 Code: errorCode, 3901 Message: errorMessage, 3902 } 3903 return genericError 3904 3905 } 3906} 3907 3908func awsAwsjson10_deserializeErrorDefaultUndefinedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3909 var buff [1024]byte 3910 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3911 3912 body := io.TeeReader(errorBody, ringBuffer) 3913 decoder := json.NewDecoder(body) 3914 decoder.UseNumber() 3915 var shape interface{} 3916 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3917 var snapshot bytes.Buffer 3918 io.Copy(&snapshot, ringBuffer) 3919 err = &smithy.DeserializationError{ 3920 Err: fmt.Errorf("failed to decode response body, %w", err), 3921 Snapshot: snapshot.Bytes(), 3922 } 3923 return err 3924 } 3925 3926 output := &types.DefaultUndefinedFault{} 3927 err := awsAwsjson10_deserializeDocumentDefaultUndefinedFault(&output, shape) 3928 3929 if err != nil { 3930 var snapshot bytes.Buffer 3931 io.Copy(&snapshot, ringBuffer) 3932 err = &smithy.DeserializationError{ 3933 Err: fmt.Errorf("failed to decode response body, %w", err), 3934 Snapshot: snapshot.Bytes(), 3935 } 3936 return err 3937 } 3938 3939 errorBody.Seek(0, io.SeekStart) 3940 return output 3941} 3942 3943func awsAwsjson10_deserializeErrorDomainAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3944 var buff [1024]byte 3945 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3946 3947 body := io.TeeReader(errorBody, ringBuffer) 3948 decoder := json.NewDecoder(body) 3949 decoder.UseNumber() 3950 var shape interface{} 3951 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3952 var snapshot bytes.Buffer 3953 io.Copy(&snapshot, ringBuffer) 3954 err = &smithy.DeserializationError{ 3955 Err: fmt.Errorf("failed to decode response body, %w", err), 3956 Snapshot: snapshot.Bytes(), 3957 } 3958 return err 3959 } 3960 3961 output := &types.DomainAlreadyExistsFault{} 3962 err := awsAwsjson10_deserializeDocumentDomainAlreadyExistsFault(&output, shape) 3963 3964 if err != nil { 3965 var snapshot bytes.Buffer 3966 io.Copy(&snapshot, ringBuffer) 3967 err = &smithy.DeserializationError{ 3968 Err: fmt.Errorf("failed to decode response body, %w", err), 3969 Snapshot: snapshot.Bytes(), 3970 } 3971 return err 3972 } 3973 3974 errorBody.Seek(0, io.SeekStart) 3975 return output 3976} 3977 3978func awsAwsjson10_deserializeErrorDomainDeprecatedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3979 var buff [1024]byte 3980 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3981 3982 body := io.TeeReader(errorBody, ringBuffer) 3983 decoder := json.NewDecoder(body) 3984 decoder.UseNumber() 3985 var shape interface{} 3986 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3987 var snapshot bytes.Buffer 3988 io.Copy(&snapshot, ringBuffer) 3989 err = &smithy.DeserializationError{ 3990 Err: fmt.Errorf("failed to decode response body, %w", err), 3991 Snapshot: snapshot.Bytes(), 3992 } 3993 return err 3994 } 3995 3996 output := &types.DomainDeprecatedFault{} 3997 err := awsAwsjson10_deserializeDocumentDomainDeprecatedFault(&output, shape) 3998 3999 if err != nil { 4000 var snapshot bytes.Buffer 4001 io.Copy(&snapshot, ringBuffer) 4002 err = &smithy.DeserializationError{ 4003 Err: fmt.Errorf("failed to decode response body, %w", err), 4004 Snapshot: snapshot.Bytes(), 4005 } 4006 return err 4007 } 4008 4009 errorBody.Seek(0, io.SeekStart) 4010 return output 4011} 4012 4013func awsAwsjson10_deserializeErrorLimitExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4014 var buff [1024]byte 4015 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4016 4017 body := io.TeeReader(errorBody, ringBuffer) 4018 decoder := json.NewDecoder(body) 4019 decoder.UseNumber() 4020 var shape interface{} 4021 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4022 var snapshot bytes.Buffer 4023 io.Copy(&snapshot, ringBuffer) 4024 err = &smithy.DeserializationError{ 4025 Err: fmt.Errorf("failed to decode response body, %w", err), 4026 Snapshot: snapshot.Bytes(), 4027 } 4028 return err 4029 } 4030 4031 output := &types.LimitExceededFault{} 4032 err := awsAwsjson10_deserializeDocumentLimitExceededFault(&output, shape) 4033 4034 if err != nil { 4035 var snapshot bytes.Buffer 4036 io.Copy(&snapshot, ringBuffer) 4037 err = &smithy.DeserializationError{ 4038 Err: fmt.Errorf("failed to decode response body, %w", err), 4039 Snapshot: snapshot.Bytes(), 4040 } 4041 return err 4042 } 4043 4044 errorBody.Seek(0, io.SeekStart) 4045 return output 4046} 4047 4048func awsAwsjson10_deserializeErrorOperationNotPermittedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4049 var buff [1024]byte 4050 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4051 4052 body := io.TeeReader(errorBody, ringBuffer) 4053 decoder := json.NewDecoder(body) 4054 decoder.UseNumber() 4055 var shape interface{} 4056 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4057 var snapshot bytes.Buffer 4058 io.Copy(&snapshot, ringBuffer) 4059 err = &smithy.DeserializationError{ 4060 Err: fmt.Errorf("failed to decode response body, %w", err), 4061 Snapshot: snapshot.Bytes(), 4062 } 4063 return err 4064 } 4065 4066 output := &types.OperationNotPermittedFault{} 4067 err := awsAwsjson10_deserializeDocumentOperationNotPermittedFault(&output, shape) 4068 4069 if err != nil { 4070 var snapshot bytes.Buffer 4071 io.Copy(&snapshot, ringBuffer) 4072 err = &smithy.DeserializationError{ 4073 Err: fmt.Errorf("failed to decode response body, %w", err), 4074 Snapshot: snapshot.Bytes(), 4075 } 4076 return err 4077 } 4078 4079 errorBody.Seek(0, io.SeekStart) 4080 return output 4081} 4082 4083func awsAwsjson10_deserializeErrorTooManyTagsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4084 var buff [1024]byte 4085 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4086 4087 body := io.TeeReader(errorBody, ringBuffer) 4088 decoder := json.NewDecoder(body) 4089 decoder.UseNumber() 4090 var shape interface{} 4091 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4092 var snapshot bytes.Buffer 4093 io.Copy(&snapshot, ringBuffer) 4094 err = &smithy.DeserializationError{ 4095 Err: fmt.Errorf("failed to decode response body, %w", err), 4096 Snapshot: snapshot.Bytes(), 4097 } 4098 return err 4099 } 4100 4101 output := &types.TooManyTagsFault{} 4102 err := awsAwsjson10_deserializeDocumentTooManyTagsFault(&output, shape) 4103 4104 if err != nil { 4105 var snapshot bytes.Buffer 4106 io.Copy(&snapshot, ringBuffer) 4107 err = &smithy.DeserializationError{ 4108 Err: fmt.Errorf("failed to decode response body, %w", err), 4109 Snapshot: snapshot.Bytes(), 4110 } 4111 return err 4112 } 4113 4114 errorBody.Seek(0, io.SeekStart) 4115 return output 4116} 4117 4118func awsAwsjson10_deserializeErrorTypeAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4119 var buff [1024]byte 4120 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4121 4122 body := io.TeeReader(errorBody, ringBuffer) 4123 decoder := json.NewDecoder(body) 4124 decoder.UseNumber() 4125 var shape interface{} 4126 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4127 var snapshot bytes.Buffer 4128 io.Copy(&snapshot, ringBuffer) 4129 err = &smithy.DeserializationError{ 4130 Err: fmt.Errorf("failed to decode response body, %w", err), 4131 Snapshot: snapshot.Bytes(), 4132 } 4133 return err 4134 } 4135 4136 output := &types.TypeAlreadyExistsFault{} 4137 err := awsAwsjson10_deserializeDocumentTypeAlreadyExistsFault(&output, shape) 4138 4139 if err != nil { 4140 var snapshot bytes.Buffer 4141 io.Copy(&snapshot, ringBuffer) 4142 err = &smithy.DeserializationError{ 4143 Err: fmt.Errorf("failed to decode response body, %w", err), 4144 Snapshot: snapshot.Bytes(), 4145 } 4146 return err 4147 } 4148 4149 errorBody.Seek(0, io.SeekStart) 4150 return output 4151} 4152 4153func awsAwsjson10_deserializeErrorTypeDeprecatedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4154 var buff [1024]byte 4155 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4156 4157 body := io.TeeReader(errorBody, 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 err 4169 } 4170 4171 output := &types.TypeDeprecatedFault{} 4172 err := awsAwsjson10_deserializeDocumentTypeDeprecatedFault(&output, shape) 4173 4174 if err != nil { 4175 var snapshot bytes.Buffer 4176 io.Copy(&snapshot, ringBuffer) 4177 err = &smithy.DeserializationError{ 4178 Err: fmt.Errorf("failed to decode response body, %w", err), 4179 Snapshot: snapshot.Bytes(), 4180 } 4181 return err 4182 } 4183 4184 errorBody.Seek(0, io.SeekStart) 4185 return output 4186} 4187 4188func awsAwsjson10_deserializeErrorUnknownResourceFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4189 var buff [1024]byte 4190 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4191 4192 body := io.TeeReader(errorBody, ringBuffer) 4193 decoder := json.NewDecoder(body) 4194 decoder.UseNumber() 4195 var shape interface{} 4196 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4197 var snapshot bytes.Buffer 4198 io.Copy(&snapshot, ringBuffer) 4199 err = &smithy.DeserializationError{ 4200 Err: fmt.Errorf("failed to decode response body, %w", err), 4201 Snapshot: snapshot.Bytes(), 4202 } 4203 return err 4204 } 4205 4206 output := &types.UnknownResourceFault{} 4207 err := awsAwsjson10_deserializeDocumentUnknownResourceFault(&output, shape) 4208 4209 if err != nil { 4210 var snapshot bytes.Buffer 4211 io.Copy(&snapshot, ringBuffer) 4212 err = &smithy.DeserializationError{ 4213 Err: fmt.Errorf("failed to decode response body, %w", err), 4214 Snapshot: snapshot.Bytes(), 4215 } 4216 return err 4217 } 4218 4219 errorBody.Seek(0, io.SeekStart) 4220 return output 4221} 4222 4223func awsAwsjson10_deserializeErrorWorkflowExecutionAlreadyStartedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4224 var buff [1024]byte 4225 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4226 4227 body := io.TeeReader(errorBody, ringBuffer) 4228 decoder := json.NewDecoder(body) 4229 decoder.UseNumber() 4230 var shape interface{} 4231 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4232 var snapshot bytes.Buffer 4233 io.Copy(&snapshot, ringBuffer) 4234 err = &smithy.DeserializationError{ 4235 Err: fmt.Errorf("failed to decode response body, %w", err), 4236 Snapshot: snapshot.Bytes(), 4237 } 4238 return err 4239 } 4240 4241 output := &types.WorkflowExecutionAlreadyStartedFault{} 4242 err := awsAwsjson10_deserializeDocumentWorkflowExecutionAlreadyStartedFault(&output, shape) 4243 4244 if err != nil { 4245 var snapshot bytes.Buffer 4246 io.Copy(&snapshot, ringBuffer) 4247 err = &smithy.DeserializationError{ 4248 Err: fmt.Errorf("failed to decode response body, %w", err), 4249 Snapshot: snapshot.Bytes(), 4250 } 4251 return err 4252 } 4253 4254 errorBody.Seek(0, io.SeekStart) 4255 return output 4256} 4257 4258func awsAwsjson10_deserializeDocumentActivityTaskCanceledEventAttributes(v **types.ActivityTaskCanceledEventAttributes, value interface{}) error { 4259 if v == nil { 4260 return fmt.Errorf("unexpected nil of type %T", v) 4261 } 4262 if value == nil { 4263 return nil 4264 } 4265 4266 shape, ok := value.(map[string]interface{}) 4267 if !ok { 4268 return fmt.Errorf("unexpected JSON type %v", value) 4269 } 4270 4271 var sv *types.ActivityTaskCanceledEventAttributes 4272 if *v == nil { 4273 sv = &types.ActivityTaskCanceledEventAttributes{} 4274 } else { 4275 sv = *v 4276 } 4277 4278 for key, value := range shape { 4279 switch key { 4280 case "details": 4281 if value != nil { 4282 jtv, ok := value.(string) 4283 if !ok { 4284 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 4285 } 4286 sv.Details = ptr.String(jtv) 4287 } 4288 4289 case "latestCancelRequestedEventId": 4290 if value != nil { 4291 jtv, ok := value.(json.Number) 4292 if !ok { 4293 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 4294 } 4295 i64, err := jtv.Int64() 4296 if err != nil { 4297 return err 4298 } 4299 sv.LatestCancelRequestedEventId = i64 4300 } 4301 4302 case "scheduledEventId": 4303 if value != nil { 4304 jtv, ok := value.(json.Number) 4305 if !ok { 4306 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 4307 } 4308 i64, err := jtv.Int64() 4309 if err != nil { 4310 return err 4311 } 4312 sv.ScheduledEventId = i64 4313 } 4314 4315 case "startedEventId": 4316 if value != nil { 4317 jtv, ok := value.(json.Number) 4318 if !ok { 4319 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 4320 } 4321 i64, err := jtv.Int64() 4322 if err != nil { 4323 return err 4324 } 4325 sv.StartedEventId = i64 4326 } 4327 4328 default: 4329 _, _ = key, value 4330 4331 } 4332 } 4333 *v = sv 4334 return nil 4335} 4336 4337func awsAwsjson10_deserializeDocumentActivityTaskCancelRequestedEventAttributes(v **types.ActivityTaskCancelRequestedEventAttributes, value interface{}) error { 4338 if v == nil { 4339 return fmt.Errorf("unexpected nil of type %T", v) 4340 } 4341 if value == nil { 4342 return nil 4343 } 4344 4345 shape, ok := value.(map[string]interface{}) 4346 if !ok { 4347 return fmt.Errorf("unexpected JSON type %v", value) 4348 } 4349 4350 var sv *types.ActivityTaskCancelRequestedEventAttributes 4351 if *v == nil { 4352 sv = &types.ActivityTaskCancelRequestedEventAttributes{} 4353 } else { 4354 sv = *v 4355 } 4356 4357 for key, value := range shape { 4358 switch key { 4359 case "activityId": 4360 if value != nil { 4361 jtv, ok := value.(string) 4362 if !ok { 4363 return fmt.Errorf("expected ActivityId to be of type string, got %T instead", value) 4364 } 4365 sv.ActivityId = ptr.String(jtv) 4366 } 4367 4368 case "decisionTaskCompletedEventId": 4369 if value != nil { 4370 jtv, ok := value.(json.Number) 4371 if !ok { 4372 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 4373 } 4374 i64, err := jtv.Int64() 4375 if err != nil { 4376 return err 4377 } 4378 sv.DecisionTaskCompletedEventId = i64 4379 } 4380 4381 default: 4382 _, _ = key, value 4383 4384 } 4385 } 4386 *v = sv 4387 return nil 4388} 4389 4390func awsAwsjson10_deserializeDocumentActivityTaskCompletedEventAttributes(v **types.ActivityTaskCompletedEventAttributes, value interface{}) error { 4391 if v == nil { 4392 return fmt.Errorf("unexpected nil of type %T", v) 4393 } 4394 if value == nil { 4395 return nil 4396 } 4397 4398 shape, ok := value.(map[string]interface{}) 4399 if !ok { 4400 return fmt.Errorf("unexpected JSON type %v", value) 4401 } 4402 4403 var sv *types.ActivityTaskCompletedEventAttributes 4404 if *v == nil { 4405 sv = &types.ActivityTaskCompletedEventAttributes{} 4406 } else { 4407 sv = *v 4408 } 4409 4410 for key, value := range shape { 4411 switch key { 4412 case "result": 4413 if value != nil { 4414 jtv, ok := value.(string) 4415 if !ok { 4416 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 4417 } 4418 sv.Result = ptr.String(jtv) 4419 } 4420 4421 case "scheduledEventId": 4422 if value != nil { 4423 jtv, ok := value.(json.Number) 4424 if !ok { 4425 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 4426 } 4427 i64, err := jtv.Int64() 4428 if err != nil { 4429 return err 4430 } 4431 sv.ScheduledEventId = i64 4432 } 4433 4434 case "startedEventId": 4435 if value != nil { 4436 jtv, ok := value.(json.Number) 4437 if !ok { 4438 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 4439 } 4440 i64, err := jtv.Int64() 4441 if err != nil { 4442 return err 4443 } 4444 sv.StartedEventId = i64 4445 } 4446 4447 default: 4448 _, _ = key, value 4449 4450 } 4451 } 4452 *v = sv 4453 return nil 4454} 4455 4456func awsAwsjson10_deserializeDocumentActivityTaskFailedEventAttributes(v **types.ActivityTaskFailedEventAttributes, value interface{}) error { 4457 if v == nil { 4458 return fmt.Errorf("unexpected nil of type %T", v) 4459 } 4460 if value == nil { 4461 return nil 4462 } 4463 4464 shape, ok := value.(map[string]interface{}) 4465 if !ok { 4466 return fmt.Errorf("unexpected JSON type %v", value) 4467 } 4468 4469 var sv *types.ActivityTaskFailedEventAttributes 4470 if *v == nil { 4471 sv = &types.ActivityTaskFailedEventAttributes{} 4472 } else { 4473 sv = *v 4474 } 4475 4476 for key, value := range shape { 4477 switch key { 4478 case "details": 4479 if value != nil { 4480 jtv, ok := value.(string) 4481 if !ok { 4482 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 4483 } 4484 sv.Details = ptr.String(jtv) 4485 } 4486 4487 case "reason": 4488 if value != nil { 4489 jtv, ok := value.(string) 4490 if !ok { 4491 return fmt.Errorf("expected FailureReason to be of type string, got %T instead", value) 4492 } 4493 sv.Reason = ptr.String(jtv) 4494 } 4495 4496 case "scheduledEventId": 4497 if value != nil { 4498 jtv, ok := value.(json.Number) 4499 if !ok { 4500 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 4501 } 4502 i64, err := jtv.Int64() 4503 if err != nil { 4504 return err 4505 } 4506 sv.ScheduledEventId = i64 4507 } 4508 4509 case "startedEventId": 4510 if value != nil { 4511 jtv, ok := value.(json.Number) 4512 if !ok { 4513 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 4514 } 4515 i64, err := jtv.Int64() 4516 if err != nil { 4517 return err 4518 } 4519 sv.StartedEventId = i64 4520 } 4521 4522 default: 4523 _, _ = key, value 4524 4525 } 4526 } 4527 *v = sv 4528 return nil 4529} 4530 4531func awsAwsjson10_deserializeDocumentActivityTaskScheduledEventAttributes(v **types.ActivityTaskScheduledEventAttributes, value interface{}) error { 4532 if v == nil { 4533 return fmt.Errorf("unexpected nil of type %T", v) 4534 } 4535 if value == nil { 4536 return nil 4537 } 4538 4539 shape, ok := value.(map[string]interface{}) 4540 if !ok { 4541 return fmt.Errorf("unexpected JSON type %v", value) 4542 } 4543 4544 var sv *types.ActivityTaskScheduledEventAttributes 4545 if *v == nil { 4546 sv = &types.ActivityTaskScheduledEventAttributes{} 4547 } else { 4548 sv = *v 4549 } 4550 4551 for key, value := range shape { 4552 switch key { 4553 case "activityId": 4554 if value != nil { 4555 jtv, ok := value.(string) 4556 if !ok { 4557 return fmt.Errorf("expected ActivityId to be of type string, got %T instead", value) 4558 } 4559 sv.ActivityId = ptr.String(jtv) 4560 } 4561 4562 case "activityType": 4563 if err := awsAwsjson10_deserializeDocumentActivityType(&sv.ActivityType, value); err != nil { 4564 return err 4565 } 4566 4567 case "control": 4568 if value != nil { 4569 jtv, ok := value.(string) 4570 if !ok { 4571 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 4572 } 4573 sv.Control = ptr.String(jtv) 4574 } 4575 4576 case "decisionTaskCompletedEventId": 4577 if value != nil { 4578 jtv, ok := value.(json.Number) 4579 if !ok { 4580 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 4581 } 4582 i64, err := jtv.Int64() 4583 if err != nil { 4584 return err 4585 } 4586 sv.DecisionTaskCompletedEventId = i64 4587 } 4588 4589 case "heartbeatTimeout": 4590 if value != nil { 4591 jtv, ok := value.(string) 4592 if !ok { 4593 return fmt.Errorf("expected DurationInSecondsOptional to be of type string, got %T instead", value) 4594 } 4595 sv.HeartbeatTimeout = ptr.String(jtv) 4596 } 4597 4598 case "input": 4599 if value != nil { 4600 jtv, ok := value.(string) 4601 if !ok { 4602 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 4603 } 4604 sv.Input = ptr.String(jtv) 4605 } 4606 4607 case "scheduleToCloseTimeout": 4608 if value != nil { 4609 jtv, ok := value.(string) 4610 if !ok { 4611 return fmt.Errorf("expected DurationInSecondsOptional to be of type string, got %T instead", value) 4612 } 4613 sv.ScheduleToCloseTimeout = ptr.String(jtv) 4614 } 4615 4616 case "scheduleToStartTimeout": 4617 if value != nil { 4618 jtv, ok := value.(string) 4619 if !ok { 4620 return fmt.Errorf("expected DurationInSecondsOptional to be of type string, got %T instead", value) 4621 } 4622 sv.ScheduleToStartTimeout = ptr.String(jtv) 4623 } 4624 4625 case "startToCloseTimeout": 4626 if value != nil { 4627 jtv, ok := value.(string) 4628 if !ok { 4629 return fmt.Errorf("expected DurationInSecondsOptional to be of type string, got %T instead", value) 4630 } 4631 sv.StartToCloseTimeout = ptr.String(jtv) 4632 } 4633 4634 case "taskList": 4635 if err := awsAwsjson10_deserializeDocumentTaskList(&sv.TaskList, value); err != nil { 4636 return err 4637 } 4638 4639 case "taskPriority": 4640 if value != nil { 4641 jtv, ok := value.(string) 4642 if !ok { 4643 return fmt.Errorf("expected TaskPriority to be of type string, got %T instead", value) 4644 } 4645 sv.TaskPriority = ptr.String(jtv) 4646 } 4647 4648 default: 4649 _, _ = key, value 4650 4651 } 4652 } 4653 *v = sv 4654 return nil 4655} 4656 4657func awsAwsjson10_deserializeDocumentActivityTaskStartedEventAttributes(v **types.ActivityTaskStartedEventAttributes, value interface{}) error { 4658 if v == nil { 4659 return fmt.Errorf("unexpected nil of type %T", v) 4660 } 4661 if value == nil { 4662 return nil 4663 } 4664 4665 shape, ok := value.(map[string]interface{}) 4666 if !ok { 4667 return fmt.Errorf("unexpected JSON type %v", value) 4668 } 4669 4670 var sv *types.ActivityTaskStartedEventAttributes 4671 if *v == nil { 4672 sv = &types.ActivityTaskStartedEventAttributes{} 4673 } else { 4674 sv = *v 4675 } 4676 4677 for key, value := range shape { 4678 switch key { 4679 case "identity": 4680 if value != nil { 4681 jtv, ok := value.(string) 4682 if !ok { 4683 return fmt.Errorf("expected Identity to be of type string, got %T instead", value) 4684 } 4685 sv.Identity = ptr.String(jtv) 4686 } 4687 4688 case "scheduledEventId": 4689 if value != nil { 4690 jtv, ok := value.(json.Number) 4691 if !ok { 4692 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 4693 } 4694 i64, err := jtv.Int64() 4695 if err != nil { 4696 return err 4697 } 4698 sv.ScheduledEventId = i64 4699 } 4700 4701 default: 4702 _, _ = key, value 4703 4704 } 4705 } 4706 *v = sv 4707 return nil 4708} 4709 4710func awsAwsjson10_deserializeDocumentActivityTaskTimedOutEventAttributes(v **types.ActivityTaskTimedOutEventAttributes, value interface{}) error { 4711 if v == nil { 4712 return fmt.Errorf("unexpected nil of type %T", v) 4713 } 4714 if value == nil { 4715 return nil 4716 } 4717 4718 shape, ok := value.(map[string]interface{}) 4719 if !ok { 4720 return fmt.Errorf("unexpected JSON type %v", value) 4721 } 4722 4723 var sv *types.ActivityTaskTimedOutEventAttributes 4724 if *v == nil { 4725 sv = &types.ActivityTaskTimedOutEventAttributes{} 4726 } else { 4727 sv = *v 4728 } 4729 4730 for key, value := range shape { 4731 switch key { 4732 case "details": 4733 if value != nil { 4734 jtv, ok := value.(string) 4735 if !ok { 4736 return fmt.Errorf("expected LimitedData to be of type string, got %T instead", value) 4737 } 4738 sv.Details = ptr.String(jtv) 4739 } 4740 4741 case "scheduledEventId": 4742 if value != nil { 4743 jtv, ok := value.(json.Number) 4744 if !ok { 4745 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 4746 } 4747 i64, err := jtv.Int64() 4748 if err != nil { 4749 return err 4750 } 4751 sv.ScheduledEventId = i64 4752 } 4753 4754 case "startedEventId": 4755 if value != nil { 4756 jtv, ok := value.(json.Number) 4757 if !ok { 4758 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 4759 } 4760 i64, err := jtv.Int64() 4761 if err != nil { 4762 return err 4763 } 4764 sv.StartedEventId = i64 4765 } 4766 4767 case "timeoutType": 4768 if value != nil { 4769 jtv, ok := value.(string) 4770 if !ok { 4771 return fmt.Errorf("expected ActivityTaskTimeoutType to be of type string, got %T instead", value) 4772 } 4773 sv.TimeoutType = types.ActivityTaskTimeoutType(jtv) 4774 } 4775 4776 default: 4777 _, _ = key, value 4778 4779 } 4780 } 4781 *v = sv 4782 return nil 4783} 4784 4785func awsAwsjson10_deserializeDocumentActivityType(v **types.ActivityType, value interface{}) error { 4786 if v == nil { 4787 return fmt.Errorf("unexpected nil of type %T", v) 4788 } 4789 if value == nil { 4790 return nil 4791 } 4792 4793 shape, ok := value.(map[string]interface{}) 4794 if !ok { 4795 return fmt.Errorf("unexpected JSON type %v", value) 4796 } 4797 4798 var sv *types.ActivityType 4799 if *v == nil { 4800 sv = &types.ActivityType{} 4801 } else { 4802 sv = *v 4803 } 4804 4805 for key, value := range shape { 4806 switch key { 4807 case "name": 4808 if value != nil { 4809 jtv, ok := value.(string) 4810 if !ok { 4811 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 4812 } 4813 sv.Name = ptr.String(jtv) 4814 } 4815 4816 case "version": 4817 if value != nil { 4818 jtv, ok := value.(string) 4819 if !ok { 4820 return fmt.Errorf("expected Version to be of type string, got %T instead", value) 4821 } 4822 sv.Version = ptr.String(jtv) 4823 } 4824 4825 default: 4826 _, _ = key, value 4827 4828 } 4829 } 4830 *v = sv 4831 return nil 4832} 4833 4834func awsAwsjson10_deserializeDocumentActivityTypeConfiguration(v **types.ActivityTypeConfiguration, value interface{}) error { 4835 if v == nil { 4836 return fmt.Errorf("unexpected nil of type %T", v) 4837 } 4838 if value == nil { 4839 return nil 4840 } 4841 4842 shape, ok := value.(map[string]interface{}) 4843 if !ok { 4844 return fmt.Errorf("unexpected JSON type %v", value) 4845 } 4846 4847 var sv *types.ActivityTypeConfiguration 4848 if *v == nil { 4849 sv = &types.ActivityTypeConfiguration{} 4850 } else { 4851 sv = *v 4852 } 4853 4854 for key, value := range shape { 4855 switch key { 4856 case "defaultTaskHeartbeatTimeout": 4857 if value != nil { 4858 jtv, ok := value.(string) 4859 if !ok { 4860 return fmt.Errorf("expected DurationInSecondsOptional to be of type string, got %T instead", value) 4861 } 4862 sv.DefaultTaskHeartbeatTimeout = ptr.String(jtv) 4863 } 4864 4865 case "defaultTaskList": 4866 if err := awsAwsjson10_deserializeDocumentTaskList(&sv.DefaultTaskList, value); err != nil { 4867 return err 4868 } 4869 4870 case "defaultTaskPriority": 4871 if value != nil { 4872 jtv, ok := value.(string) 4873 if !ok { 4874 return fmt.Errorf("expected TaskPriority to be of type string, got %T instead", value) 4875 } 4876 sv.DefaultTaskPriority = ptr.String(jtv) 4877 } 4878 4879 case "defaultTaskScheduleToCloseTimeout": 4880 if value != nil { 4881 jtv, ok := value.(string) 4882 if !ok { 4883 return fmt.Errorf("expected DurationInSecondsOptional to be of type string, got %T instead", value) 4884 } 4885 sv.DefaultTaskScheduleToCloseTimeout = ptr.String(jtv) 4886 } 4887 4888 case "defaultTaskScheduleToStartTimeout": 4889 if value != nil { 4890 jtv, ok := value.(string) 4891 if !ok { 4892 return fmt.Errorf("expected DurationInSecondsOptional to be of type string, got %T instead", value) 4893 } 4894 sv.DefaultTaskScheduleToStartTimeout = ptr.String(jtv) 4895 } 4896 4897 case "defaultTaskStartToCloseTimeout": 4898 if value != nil { 4899 jtv, ok := value.(string) 4900 if !ok { 4901 return fmt.Errorf("expected DurationInSecondsOptional to be of type string, got %T instead", value) 4902 } 4903 sv.DefaultTaskStartToCloseTimeout = ptr.String(jtv) 4904 } 4905 4906 default: 4907 _, _ = key, value 4908 4909 } 4910 } 4911 *v = sv 4912 return nil 4913} 4914 4915func awsAwsjson10_deserializeDocumentActivityTypeInfo(v **types.ActivityTypeInfo, value interface{}) error { 4916 if v == nil { 4917 return fmt.Errorf("unexpected nil of type %T", v) 4918 } 4919 if value == nil { 4920 return nil 4921 } 4922 4923 shape, ok := value.(map[string]interface{}) 4924 if !ok { 4925 return fmt.Errorf("unexpected JSON type %v", value) 4926 } 4927 4928 var sv *types.ActivityTypeInfo 4929 if *v == nil { 4930 sv = &types.ActivityTypeInfo{} 4931 } else { 4932 sv = *v 4933 } 4934 4935 for key, value := range shape { 4936 switch key { 4937 case "activityType": 4938 if err := awsAwsjson10_deserializeDocumentActivityType(&sv.ActivityType, value); err != nil { 4939 return err 4940 } 4941 4942 case "creationDate": 4943 if value != nil { 4944 jtv, ok := value.(json.Number) 4945 if !ok { 4946 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4947 } 4948 f64, err := jtv.Float64() 4949 if err != nil { 4950 return err 4951 } 4952 sv.CreationDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4953 } 4954 4955 case "deprecationDate": 4956 if value != nil { 4957 jtv, ok := value.(json.Number) 4958 if !ok { 4959 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4960 } 4961 f64, err := jtv.Float64() 4962 if err != nil { 4963 return err 4964 } 4965 sv.DeprecationDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4966 } 4967 4968 case "description": 4969 if value != nil { 4970 jtv, ok := value.(string) 4971 if !ok { 4972 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 4973 } 4974 sv.Description = ptr.String(jtv) 4975 } 4976 4977 case "status": 4978 if value != nil { 4979 jtv, ok := value.(string) 4980 if !ok { 4981 return fmt.Errorf("expected RegistrationStatus to be of type string, got %T instead", value) 4982 } 4983 sv.Status = types.RegistrationStatus(jtv) 4984 } 4985 4986 default: 4987 _, _ = key, value 4988 4989 } 4990 } 4991 *v = sv 4992 return nil 4993} 4994 4995func awsAwsjson10_deserializeDocumentActivityTypeInfoList(v *[]types.ActivityTypeInfo, value interface{}) error { 4996 if v == nil { 4997 return fmt.Errorf("unexpected nil of type %T", v) 4998 } 4999 if value == nil { 5000 return nil 5001 } 5002 5003 shape, ok := value.([]interface{}) 5004 if !ok { 5005 return fmt.Errorf("unexpected JSON type %v", value) 5006 } 5007 5008 var cv []types.ActivityTypeInfo 5009 if *v == nil { 5010 cv = []types.ActivityTypeInfo{} 5011 } else { 5012 cv = *v 5013 } 5014 5015 for _, value := range shape { 5016 var col types.ActivityTypeInfo 5017 destAddr := &col 5018 if err := awsAwsjson10_deserializeDocumentActivityTypeInfo(&destAddr, value); err != nil { 5019 return err 5020 } 5021 col = *destAddr 5022 cv = append(cv, col) 5023 5024 } 5025 *v = cv 5026 return nil 5027} 5028 5029func awsAwsjson10_deserializeDocumentCancelTimerFailedEventAttributes(v **types.CancelTimerFailedEventAttributes, value interface{}) error { 5030 if v == nil { 5031 return fmt.Errorf("unexpected nil of type %T", v) 5032 } 5033 if value == nil { 5034 return nil 5035 } 5036 5037 shape, ok := value.(map[string]interface{}) 5038 if !ok { 5039 return fmt.Errorf("unexpected JSON type %v", value) 5040 } 5041 5042 var sv *types.CancelTimerFailedEventAttributes 5043 if *v == nil { 5044 sv = &types.CancelTimerFailedEventAttributes{} 5045 } else { 5046 sv = *v 5047 } 5048 5049 for key, value := range shape { 5050 switch key { 5051 case "cause": 5052 if value != nil { 5053 jtv, ok := value.(string) 5054 if !ok { 5055 return fmt.Errorf("expected CancelTimerFailedCause to be of type string, got %T instead", value) 5056 } 5057 sv.Cause = types.CancelTimerFailedCause(jtv) 5058 } 5059 5060 case "decisionTaskCompletedEventId": 5061 if value != nil { 5062 jtv, ok := value.(json.Number) 5063 if !ok { 5064 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5065 } 5066 i64, err := jtv.Int64() 5067 if err != nil { 5068 return err 5069 } 5070 sv.DecisionTaskCompletedEventId = i64 5071 } 5072 5073 case "timerId": 5074 if value != nil { 5075 jtv, ok := value.(string) 5076 if !ok { 5077 return fmt.Errorf("expected TimerId to be of type string, got %T instead", value) 5078 } 5079 sv.TimerId = ptr.String(jtv) 5080 } 5081 5082 default: 5083 _, _ = key, value 5084 5085 } 5086 } 5087 *v = sv 5088 return nil 5089} 5090 5091func awsAwsjson10_deserializeDocumentCancelWorkflowExecutionFailedEventAttributes(v **types.CancelWorkflowExecutionFailedEventAttributes, value interface{}) error { 5092 if v == nil { 5093 return fmt.Errorf("unexpected nil of type %T", v) 5094 } 5095 if value == nil { 5096 return nil 5097 } 5098 5099 shape, ok := value.(map[string]interface{}) 5100 if !ok { 5101 return fmt.Errorf("unexpected JSON type %v", value) 5102 } 5103 5104 var sv *types.CancelWorkflowExecutionFailedEventAttributes 5105 if *v == nil { 5106 sv = &types.CancelWorkflowExecutionFailedEventAttributes{} 5107 } else { 5108 sv = *v 5109 } 5110 5111 for key, value := range shape { 5112 switch key { 5113 case "cause": 5114 if value != nil { 5115 jtv, ok := value.(string) 5116 if !ok { 5117 return fmt.Errorf("expected CancelWorkflowExecutionFailedCause to be of type string, got %T instead", value) 5118 } 5119 sv.Cause = types.CancelWorkflowExecutionFailedCause(jtv) 5120 } 5121 5122 case "decisionTaskCompletedEventId": 5123 if value != nil { 5124 jtv, ok := value.(json.Number) 5125 if !ok { 5126 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5127 } 5128 i64, err := jtv.Int64() 5129 if err != nil { 5130 return err 5131 } 5132 sv.DecisionTaskCompletedEventId = i64 5133 } 5134 5135 default: 5136 _, _ = key, value 5137 5138 } 5139 } 5140 *v = sv 5141 return nil 5142} 5143 5144func awsAwsjson10_deserializeDocumentChildWorkflowExecutionCanceledEventAttributes(v **types.ChildWorkflowExecutionCanceledEventAttributes, value interface{}) error { 5145 if v == nil { 5146 return fmt.Errorf("unexpected nil of type %T", v) 5147 } 5148 if value == nil { 5149 return nil 5150 } 5151 5152 shape, ok := value.(map[string]interface{}) 5153 if !ok { 5154 return fmt.Errorf("unexpected JSON type %v", value) 5155 } 5156 5157 var sv *types.ChildWorkflowExecutionCanceledEventAttributes 5158 if *v == nil { 5159 sv = &types.ChildWorkflowExecutionCanceledEventAttributes{} 5160 } else { 5161 sv = *v 5162 } 5163 5164 for key, value := range shape { 5165 switch key { 5166 case "details": 5167 if value != nil { 5168 jtv, ok := value.(string) 5169 if !ok { 5170 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 5171 } 5172 sv.Details = ptr.String(jtv) 5173 } 5174 5175 case "initiatedEventId": 5176 if value != nil { 5177 jtv, ok := value.(json.Number) 5178 if !ok { 5179 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5180 } 5181 i64, err := jtv.Int64() 5182 if err != nil { 5183 return err 5184 } 5185 sv.InitiatedEventId = i64 5186 } 5187 5188 case "startedEventId": 5189 if value != nil { 5190 jtv, ok := value.(json.Number) 5191 if !ok { 5192 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5193 } 5194 i64, err := jtv.Int64() 5195 if err != nil { 5196 return err 5197 } 5198 sv.StartedEventId = i64 5199 } 5200 5201 case "workflowExecution": 5202 if err := awsAwsjson10_deserializeDocumentWorkflowExecution(&sv.WorkflowExecution, value); err != nil { 5203 return err 5204 } 5205 5206 case "workflowType": 5207 if err := awsAwsjson10_deserializeDocumentWorkflowType(&sv.WorkflowType, value); err != nil { 5208 return err 5209 } 5210 5211 default: 5212 _, _ = key, value 5213 5214 } 5215 } 5216 *v = sv 5217 return nil 5218} 5219 5220func awsAwsjson10_deserializeDocumentChildWorkflowExecutionCompletedEventAttributes(v **types.ChildWorkflowExecutionCompletedEventAttributes, value interface{}) error { 5221 if v == nil { 5222 return fmt.Errorf("unexpected nil of type %T", v) 5223 } 5224 if value == nil { 5225 return nil 5226 } 5227 5228 shape, ok := value.(map[string]interface{}) 5229 if !ok { 5230 return fmt.Errorf("unexpected JSON type %v", value) 5231 } 5232 5233 var sv *types.ChildWorkflowExecutionCompletedEventAttributes 5234 if *v == nil { 5235 sv = &types.ChildWorkflowExecutionCompletedEventAttributes{} 5236 } else { 5237 sv = *v 5238 } 5239 5240 for key, value := range shape { 5241 switch key { 5242 case "initiatedEventId": 5243 if value != nil { 5244 jtv, ok := value.(json.Number) 5245 if !ok { 5246 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5247 } 5248 i64, err := jtv.Int64() 5249 if err != nil { 5250 return err 5251 } 5252 sv.InitiatedEventId = i64 5253 } 5254 5255 case "result": 5256 if value != nil { 5257 jtv, ok := value.(string) 5258 if !ok { 5259 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 5260 } 5261 sv.Result = ptr.String(jtv) 5262 } 5263 5264 case "startedEventId": 5265 if value != nil { 5266 jtv, ok := value.(json.Number) 5267 if !ok { 5268 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5269 } 5270 i64, err := jtv.Int64() 5271 if err != nil { 5272 return err 5273 } 5274 sv.StartedEventId = i64 5275 } 5276 5277 case "workflowExecution": 5278 if err := awsAwsjson10_deserializeDocumentWorkflowExecution(&sv.WorkflowExecution, value); err != nil { 5279 return err 5280 } 5281 5282 case "workflowType": 5283 if err := awsAwsjson10_deserializeDocumentWorkflowType(&sv.WorkflowType, value); err != nil { 5284 return err 5285 } 5286 5287 default: 5288 _, _ = key, value 5289 5290 } 5291 } 5292 *v = sv 5293 return nil 5294} 5295 5296func awsAwsjson10_deserializeDocumentChildWorkflowExecutionFailedEventAttributes(v **types.ChildWorkflowExecutionFailedEventAttributes, value interface{}) error { 5297 if v == nil { 5298 return fmt.Errorf("unexpected nil of type %T", v) 5299 } 5300 if value == nil { 5301 return nil 5302 } 5303 5304 shape, ok := value.(map[string]interface{}) 5305 if !ok { 5306 return fmt.Errorf("unexpected JSON type %v", value) 5307 } 5308 5309 var sv *types.ChildWorkflowExecutionFailedEventAttributes 5310 if *v == nil { 5311 sv = &types.ChildWorkflowExecutionFailedEventAttributes{} 5312 } else { 5313 sv = *v 5314 } 5315 5316 for key, value := range shape { 5317 switch key { 5318 case "details": 5319 if value != nil { 5320 jtv, ok := value.(string) 5321 if !ok { 5322 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 5323 } 5324 sv.Details = ptr.String(jtv) 5325 } 5326 5327 case "initiatedEventId": 5328 if value != nil { 5329 jtv, ok := value.(json.Number) 5330 if !ok { 5331 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5332 } 5333 i64, err := jtv.Int64() 5334 if err != nil { 5335 return err 5336 } 5337 sv.InitiatedEventId = i64 5338 } 5339 5340 case "reason": 5341 if value != nil { 5342 jtv, ok := value.(string) 5343 if !ok { 5344 return fmt.Errorf("expected FailureReason to be of type string, got %T instead", value) 5345 } 5346 sv.Reason = ptr.String(jtv) 5347 } 5348 5349 case "startedEventId": 5350 if value != nil { 5351 jtv, ok := value.(json.Number) 5352 if !ok { 5353 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5354 } 5355 i64, err := jtv.Int64() 5356 if err != nil { 5357 return err 5358 } 5359 sv.StartedEventId = i64 5360 } 5361 5362 case "workflowExecution": 5363 if err := awsAwsjson10_deserializeDocumentWorkflowExecution(&sv.WorkflowExecution, value); err != nil { 5364 return err 5365 } 5366 5367 case "workflowType": 5368 if err := awsAwsjson10_deserializeDocumentWorkflowType(&sv.WorkflowType, value); err != nil { 5369 return err 5370 } 5371 5372 default: 5373 _, _ = key, value 5374 5375 } 5376 } 5377 *v = sv 5378 return nil 5379} 5380 5381func awsAwsjson10_deserializeDocumentChildWorkflowExecutionStartedEventAttributes(v **types.ChildWorkflowExecutionStartedEventAttributes, value interface{}) error { 5382 if v == nil { 5383 return fmt.Errorf("unexpected nil of type %T", v) 5384 } 5385 if value == nil { 5386 return nil 5387 } 5388 5389 shape, ok := value.(map[string]interface{}) 5390 if !ok { 5391 return fmt.Errorf("unexpected JSON type %v", value) 5392 } 5393 5394 var sv *types.ChildWorkflowExecutionStartedEventAttributes 5395 if *v == nil { 5396 sv = &types.ChildWorkflowExecutionStartedEventAttributes{} 5397 } else { 5398 sv = *v 5399 } 5400 5401 for key, value := range shape { 5402 switch key { 5403 case "initiatedEventId": 5404 if value != nil { 5405 jtv, ok := value.(json.Number) 5406 if !ok { 5407 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5408 } 5409 i64, err := jtv.Int64() 5410 if err != nil { 5411 return err 5412 } 5413 sv.InitiatedEventId = i64 5414 } 5415 5416 case "workflowExecution": 5417 if err := awsAwsjson10_deserializeDocumentWorkflowExecution(&sv.WorkflowExecution, value); err != nil { 5418 return err 5419 } 5420 5421 case "workflowType": 5422 if err := awsAwsjson10_deserializeDocumentWorkflowType(&sv.WorkflowType, value); err != nil { 5423 return err 5424 } 5425 5426 default: 5427 _, _ = key, value 5428 5429 } 5430 } 5431 *v = sv 5432 return nil 5433} 5434 5435func awsAwsjson10_deserializeDocumentChildWorkflowExecutionTerminatedEventAttributes(v **types.ChildWorkflowExecutionTerminatedEventAttributes, value interface{}) error { 5436 if v == nil { 5437 return fmt.Errorf("unexpected nil of type %T", v) 5438 } 5439 if value == nil { 5440 return nil 5441 } 5442 5443 shape, ok := value.(map[string]interface{}) 5444 if !ok { 5445 return fmt.Errorf("unexpected JSON type %v", value) 5446 } 5447 5448 var sv *types.ChildWorkflowExecutionTerminatedEventAttributes 5449 if *v == nil { 5450 sv = &types.ChildWorkflowExecutionTerminatedEventAttributes{} 5451 } else { 5452 sv = *v 5453 } 5454 5455 for key, value := range shape { 5456 switch key { 5457 case "initiatedEventId": 5458 if value != nil { 5459 jtv, ok := value.(json.Number) 5460 if !ok { 5461 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5462 } 5463 i64, err := jtv.Int64() 5464 if err != nil { 5465 return err 5466 } 5467 sv.InitiatedEventId = i64 5468 } 5469 5470 case "startedEventId": 5471 if value != nil { 5472 jtv, ok := value.(json.Number) 5473 if !ok { 5474 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5475 } 5476 i64, err := jtv.Int64() 5477 if err != nil { 5478 return err 5479 } 5480 sv.StartedEventId = i64 5481 } 5482 5483 case "workflowExecution": 5484 if err := awsAwsjson10_deserializeDocumentWorkflowExecution(&sv.WorkflowExecution, value); err != nil { 5485 return err 5486 } 5487 5488 case "workflowType": 5489 if err := awsAwsjson10_deserializeDocumentWorkflowType(&sv.WorkflowType, value); err != nil { 5490 return err 5491 } 5492 5493 default: 5494 _, _ = key, value 5495 5496 } 5497 } 5498 *v = sv 5499 return nil 5500} 5501 5502func awsAwsjson10_deserializeDocumentChildWorkflowExecutionTimedOutEventAttributes(v **types.ChildWorkflowExecutionTimedOutEventAttributes, value interface{}) error { 5503 if v == nil { 5504 return fmt.Errorf("unexpected nil of type %T", v) 5505 } 5506 if value == nil { 5507 return nil 5508 } 5509 5510 shape, ok := value.(map[string]interface{}) 5511 if !ok { 5512 return fmt.Errorf("unexpected JSON type %v", value) 5513 } 5514 5515 var sv *types.ChildWorkflowExecutionTimedOutEventAttributes 5516 if *v == nil { 5517 sv = &types.ChildWorkflowExecutionTimedOutEventAttributes{} 5518 } else { 5519 sv = *v 5520 } 5521 5522 for key, value := range shape { 5523 switch key { 5524 case "initiatedEventId": 5525 if value != nil { 5526 jtv, ok := value.(json.Number) 5527 if !ok { 5528 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5529 } 5530 i64, err := jtv.Int64() 5531 if err != nil { 5532 return err 5533 } 5534 sv.InitiatedEventId = i64 5535 } 5536 5537 case "startedEventId": 5538 if value != nil { 5539 jtv, ok := value.(json.Number) 5540 if !ok { 5541 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5542 } 5543 i64, err := jtv.Int64() 5544 if err != nil { 5545 return err 5546 } 5547 sv.StartedEventId = i64 5548 } 5549 5550 case "timeoutType": 5551 if value != nil { 5552 jtv, ok := value.(string) 5553 if !ok { 5554 return fmt.Errorf("expected WorkflowExecutionTimeoutType to be of type string, got %T instead", value) 5555 } 5556 sv.TimeoutType = types.WorkflowExecutionTimeoutType(jtv) 5557 } 5558 5559 case "workflowExecution": 5560 if err := awsAwsjson10_deserializeDocumentWorkflowExecution(&sv.WorkflowExecution, value); err != nil { 5561 return err 5562 } 5563 5564 case "workflowType": 5565 if err := awsAwsjson10_deserializeDocumentWorkflowType(&sv.WorkflowType, value); err != nil { 5566 return err 5567 } 5568 5569 default: 5570 _, _ = key, value 5571 5572 } 5573 } 5574 *v = sv 5575 return nil 5576} 5577 5578func awsAwsjson10_deserializeDocumentCompleteWorkflowExecutionFailedEventAttributes(v **types.CompleteWorkflowExecutionFailedEventAttributes, value interface{}) error { 5579 if v == nil { 5580 return fmt.Errorf("unexpected nil of type %T", v) 5581 } 5582 if value == nil { 5583 return nil 5584 } 5585 5586 shape, ok := value.(map[string]interface{}) 5587 if !ok { 5588 return fmt.Errorf("unexpected JSON type %v", value) 5589 } 5590 5591 var sv *types.CompleteWorkflowExecutionFailedEventAttributes 5592 if *v == nil { 5593 sv = &types.CompleteWorkflowExecutionFailedEventAttributes{} 5594 } else { 5595 sv = *v 5596 } 5597 5598 for key, value := range shape { 5599 switch key { 5600 case "cause": 5601 if value != nil { 5602 jtv, ok := value.(string) 5603 if !ok { 5604 return fmt.Errorf("expected CompleteWorkflowExecutionFailedCause to be of type string, got %T instead", value) 5605 } 5606 sv.Cause = types.CompleteWorkflowExecutionFailedCause(jtv) 5607 } 5608 5609 case "decisionTaskCompletedEventId": 5610 if value != nil { 5611 jtv, ok := value.(json.Number) 5612 if !ok { 5613 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5614 } 5615 i64, err := jtv.Int64() 5616 if err != nil { 5617 return err 5618 } 5619 sv.DecisionTaskCompletedEventId = i64 5620 } 5621 5622 default: 5623 _, _ = key, value 5624 5625 } 5626 } 5627 *v = sv 5628 return nil 5629} 5630 5631func awsAwsjson10_deserializeDocumentContinueAsNewWorkflowExecutionFailedEventAttributes(v **types.ContinueAsNewWorkflowExecutionFailedEventAttributes, value interface{}) error { 5632 if v == nil { 5633 return fmt.Errorf("unexpected nil of type %T", v) 5634 } 5635 if value == nil { 5636 return nil 5637 } 5638 5639 shape, ok := value.(map[string]interface{}) 5640 if !ok { 5641 return fmt.Errorf("unexpected JSON type %v", value) 5642 } 5643 5644 var sv *types.ContinueAsNewWorkflowExecutionFailedEventAttributes 5645 if *v == nil { 5646 sv = &types.ContinueAsNewWorkflowExecutionFailedEventAttributes{} 5647 } else { 5648 sv = *v 5649 } 5650 5651 for key, value := range shape { 5652 switch key { 5653 case "cause": 5654 if value != nil { 5655 jtv, ok := value.(string) 5656 if !ok { 5657 return fmt.Errorf("expected ContinueAsNewWorkflowExecutionFailedCause to be of type string, got %T instead", value) 5658 } 5659 sv.Cause = types.ContinueAsNewWorkflowExecutionFailedCause(jtv) 5660 } 5661 5662 case "decisionTaskCompletedEventId": 5663 if value != nil { 5664 jtv, ok := value.(json.Number) 5665 if !ok { 5666 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5667 } 5668 i64, err := jtv.Int64() 5669 if err != nil { 5670 return err 5671 } 5672 sv.DecisionTaskCompletedEventId = i64 5673 } 5674 5675 default: 5676 _, _ = key, value 5677 5678 } 5679 } 5680 *v = sv 5681 return nil 5682} 5683 5684func awsAwsjson10_deserializeDocumentDecisionTaskCompletedEventAttributes(v **types.DecisionTaskCompletedEventAttributes, value interface{}) error { 5685 if v == nil { 5686 return fmt.Errorf("unexpected nil of type %T", v) 5687 } 5688 if value == nil { 5689 return nil 5690 } 5691 5692 shape, ok := value.(map[string]interface{}) 5693 if !ok { 5694 return fmt.Errorf("unexpected JSON type %v", value) 5695 } 5696 5697 var sv *types.DecisionTaskCompletedEventAttributes 5698 if *v == nil { 5699 sv = &types.DecisionTaskCompletedEventAttributes{} 5700 } else { 5701 sv = *v 5702 } 5703 5704 for key, value := range shape { 5705 switch key { 5706 case "executionContext": 5707 if value != nil { 5708 jtv, ok := value.(string) 5709 if !ok { 5710 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 5711 } 5712 sv.ExecutionContext = ptr.String(jtv) 5713 } 5714 5715 case "scheduledEventId": 5716 if value != nil { 5717 jtv, ok := value.(json.Number) 5718 if !ok { 5719 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5720 } 5721 i64, err := jtv.Int64() 5722 if err != nil { 5723 return err 5724 } 5725 sv.ScheduledEventId = i64 5726 } 5727 5728 case "startedEventId": 5729 if value != nil { 5730 jtv, ok := value.(json.Number) 5731 if !ok { 5732 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5733 } 5734 i64, err := jtv.Int64() 5735 if err != nil { 5736 return err 5737 } 5738 sv.StartedEventId = i64 5739 } 5740 5741 default: 5742 _, _ = key, value 5743 5744 } 5745 } 5746 *v = sv 5747 return nil 5748} 5749 5750func awsAwsjson10_deserializeDocumentDecisionTaskScheduledEventAttributes(v **types.DecisionTaskScheduledEventAttributes, value interface{}) error { 5751 if v == nil { 5752 return fmt.Errorf("unexpected nil of type %T", v) 5753 } 5754 if value == nil { 5755 return nil 5756 } 5757 5758 shape, ok := value.(map[string]interface{}) 5759 if !ok { 5760 return fmt.Errorf("unexpected JSON type %v", value) 5761 } 5762 5763 var sv *types.DecisionTaskScheduledEventAttributes 5764 if *v == nil { 5765 sv = &types.DecisionTaskScheduledEventAttributes{} 5766 } else { 5767 sv = *v 5768 } 5769 5770 for key, value := range shape { 5771 switch key { 5772 case "startToCloseTimeout": 5773 if value != nil { 5774 jtv, ok := value.(string) 5775 if !ok { 5776 return fmt.Errorf("expected DurationInSecondsOptional to be of type string, got %T instead", value) 5777 } 5778 sv.StartToCloseTimeout = ptr.String(jtv) 5779 } 5780 5781 case "taskList": 5782 if err := awsAwsjson10_deserializeDocumentTaskList(&sv.TaskList, value); err != nil { 5783 return err 5784 } 5785 5786 case "taskPriority": 5787 if value != nil { 5788 jtv, ok := value.(string) 5789 if !ok { 5790 return fmt.Errorf("expected TaskPriority to be of type string, got %T instead", value) 5791 } 5792 sv.TaskPriority = ptr.String(jtv) 5793 } 5794 5795 default: 5796 _, _ = key, value 5797 5798 } 5799 } 5800 *v = sv 5801 return nil 5802} 5803 5804func awsAwsjson10_deserializeDocumentDecisionTaskStartedEventAttributes(v **types.DecisionTaskStartedEventAttributes, value interface{}) error { 5805 if v == nil { 5806 return fmt.Errorf("unexpected nil of type %T", v) 5807 } 5808 if value == nil { 5809 return nil 5810 } 5811 5812 shape, ok := value.(map[string]interface{}) 5813 if !ok { 5814 return fmt.Errorf("unexpected JSON type %v", value) 5815 } 5816 5817 var sv *types.DecisionTaskStartedEventAttributes 5818 if *v == nil { 5819 sv = &types.DecisionTaskStartedEventAttributes{} 5820 } else { 5821 sv = *v 5822 } 5823 5824 for key, value := range shape { 5825 switch key { 5826 case "identity": 5827 if value != nil { 5828 jtv, ok := value.(string) 5829 if !ok { 5830 return fmt.Errorf("expected Identity to be of type string, got %T instead", value) 5831 } 5832 sv.Identity = ptr.String(jtv) 5833 } 5834 5835 case "scheduledEventId": 5836 if value != nil { 5837 jtv, ok := value.(json.Number) 5838 if !ok { 5839 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5840 } 5841 i64, err := jtv.Int64() 5842 if err != nil { 5843 return err 5844 } 5845 sv.ScheduledEventId = i64 5846 } 5847 5848 default: 5849 _, _ = key, value 5850 5851 } 5852 } 5853 *v = sv 5854 return nil 5855} 5856 5857func awsAwsjson10_deserializeDocumentDecisionTaskTimedOutEventAttributes(v **types.DecisionTaskTimedOutEventAttributes, value interface{}) error { 5858 if v == nil { 5859 return fmt.Errorf("unexpected nil of type %T", v) 5860 } 5861 if value == nil { 5862 return nil 5863 } 5864 5865 shape, ok := value.(map[string]interface{}) 5866 if !ok { 5867 return fmt.Errorf("unexpected JSON type %v", value) 5868 } 5869 5870 var sv *types.DecisionTaskTimedOutEventAttributes 5871 if *v == nil { 5872 sv = &types.DecisionTaskTimedOutEventAttributes{} 5873 } else { 5874 sv = *v 5875 } 5876 5877 for key, value := range shape { 5878 switch key { 5879 case "scheduledEventId": 5880 if value != nil { 5881 jtv, ok := value.(json.Number) 5882 if !ok { 5883 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5884 } 5885 i64, err := jtv.Int64() 5886 if err != nil { 5887 return err 5888 } 5889 sv.ScheduledEventId = i64 5890 } 5891 5892 case "startedEventId": 5893 if value != nil { 5894 jtv, ok := value.(json.Number) 5895 if !ok { 5896 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 5897 } 5898 i64, err := jtv.Int64() 5899 if err != nil { 5900 return err 5901 } 5902 sv.StartedEventId = i64 5903 } 5904 5905 case "timeoutType": 5906 if value != nil { 5907 jtv, ok := value.(string) 5908 if !ok { 5909 return fmt.Errorf("expected DecisionTaskTimeoutType to be of type string, got %T instead", value) 5910 } 5911 sv.TimeoutType = types.DecisionTaskTimeoutType(jtv) 5912 } 5913 5914 default: 5915 _, _ = key, value 5916 5917 } 5918 } 5919 *v = sv 5920 return nil 5921} 5922 5923func awsAwsjson10_deserializeDocumentDefaultUndefinedFault(v **types.DefaultUndefinedFault, value interface{}) error { 5924 if v == nil { 5925 return fmt.Errorf("unexpected nil of type %T", v) 5926 } 5927 if value == nil { 5928 return nil 5929 } 5930 5931 shape, ok := value.(map[string]interface{}) 5932 if !ok { 5933 return fmt.Errorf("unexpected JSON type %v", value) 5934 } 5935 5936 var sv *types.DefaultUndefinedFault 5937 if *v == nil { 5938 sv = &types.DefaultUndefinedFault{} 5939 } else { 5940 sv = *v 5941 } 5942 5943 for key, value := range shape { 5944 switch key { 5945 case "message": 5946 if value != nil { 5947 jtv, ok := value.(string) 5948 if !ok { 5949 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5950 } 5951 sv.Message = ptr.String(jtv) 5952 } 5953 5954 default: 5955 _, _ = key, value 5956 5957 } 5958 } 5959 *v = sv 5960 return nil 5961} 5962 5963func awsAwsjson10_deserializeDocumentDomainAlreadyExistsFault(v **types.DomainAlreadyExistsFault, value interface{}) error { 5964 if v == nil { 5965 return fmt.Errorf("unexpected nil of type %T", v) 5966 } 5967 if value == nil { 5968 return nil 5969 } 5970 5971 shape, ok := value.(map[string]interface{}) 5972 if !ok { 5973 return fmt.Errorf("unexpected JSON type %v", value) 5974 } 5975 5976 var sv *types.DomainAlreadyExistsFault 5977 if *v == nil { 5978 sv = &types.DomainAlreadyExistsFault{} 5979 } else { 5980 sv = *v 5981 } 5982 5983 for key, value := range shape { 5984 switch key { 5985 case "message": 5986 if value != nil { 5987 jtv, ok := value.(string) 5988 if !ok { 5989 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5990 } 5991 sv.Message = ptr.String(jtv) 5992 } 5993 5994 default: 5995 _, _ = key, value 5996 5997 } 5998 } 5999 *v = sv 6000 return nil 6001} 6002 6003func awsAwsjson10_deserializeDocumentDomainConfiguration(v **types.DomainConfiguration, value interface{}) error { 6004 if v == nil { 6005 return fmt.Errorf("unexpected nil of type %T", v) 6006 } 6007 if value == nil { 6008 return nil 6009 } 6010 6011 shape, ok := value.(map[string]interface{}) 6012 if !ok { 6013 return fmt.Errorf("unexpected JSON type %v", value) 6014 } 6015 6016 var sv *types.DomainConfiguration 6017 if *v == nil { 6018 sv = &types.DomainConfiguration{} 6019 } else { 6020 sv = *v 6021 } 6022 6023 for key, value := range shape { 6024 switch key { 6025 case "workflowExecutionRetentionPeriodInDays": 6026 if value != nil { 6027 jtv, ok := value.(string) 6028 if !ok { 6029 return fmt.Errorf("expected DurationInDays to be of type string, got %T instead", value) 6030 } 6031 sv.WorkflowExecutionRetentionPeriodInDays = ptr.String(jtv) 6032 } 6033 6034 default: 6035 _, _ = key, value 6036 6037 } 6038 } 6039 *v = sv 6040 return nil 6041} 6042 6043func awsAwsjson10_deserializeDocumentDomainDeprecatedFault(v **types.DomainDeprecatedFault, value interface{}) error { 6044 if v == nil { 6045 return fmt.Errorf("unexpected nil of type %T", v) 6046 } 6047 if value == nil { 6048 return nil 6049 } 6050 6051 shape, ok := value.(map[string]interface{}) 6052 if !ok { 6053 return fmt.Errorf("unexpected JSON type %v", value) 6054 } 6055 6056 var sv *types.DomainDeprecatedFault 6057 if *v == nil { 6058 sv = &types.DomainDeprecatedFault{} 6059 } else { 6060 sv = *v 6061 } 6062 6063 for key, value := range shape { 6064 switch key { 6065 case "message": 6066 if value != nil { 6067 jtv, ok := value.(string) 6068 if !ok { 6069 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6070 } 6071 sv.Message = ptr.String(jtv) 6072 } 6073 6074 default: 6075 _, _ = key, value 6076 6077 } 6078 } 6079 *v = sv 6080 return nil 6081} 6082 6083func awsAwsjson10_deserializeDocumentDomainInfo(v **types.DomainInfo, value interface{}) error { 6084 if v == nil { 6085 return fmt.Errorf("unexpected nil of type %T", v) 6086 } 6087 if value == nil { 6088 return nil 6089 } 6090 6091 shape, ok := value.(map[string]interface{}) 6092 if !ok { 6093 return fmt.Errorf("unexpected JSON type %v", value) 6094 } 6095 6096 var sv *types.DomainInfo 6097 if *v == nil { 6098 sv = &types.DomainInfo{} 6099 } else { 6100 sv = *v 6101 } 6102 6103 for key, value := range shape { 6104 switch key { 6105 case "arn": 6106 if value != nil { 6107 jtv, ok := value.(string) 6108 if !ok { 6109 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 6110 } 6111 sv.Arn = ptr.String(jtv) 6112 } 6113 6114 case "description": 6115 if value != nil { 6116 jtv, ok := value.(string) 6117 if !ok { 6118 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 6119 } 6120 sv.Description = ptr.String(jtv) 6121 } 6122 6123 case "name": 6124 if value != nil { 6125 jtv, ok := value.(string) 6126 if !ok { 6127 return fmt.Errorf("expected DomainName to be of type string, got %T instead", value) 6128 } 6129 sv.Name = ptr.String(jtv) 6130 } 6131 6132 case "status": 6133 if value != nil { 6134 jtv, ok := value.(string) 6135 if !ok { 6136 return fmt.Errorf("expected RegistrationStatus to be of type string, got %T instead", value) 6137 } 6138 sv.Status = types.RegistrationStatus(jtv) 6139 } 6140 6141 default: 6142 _, _ = key, value 6143 6144 } 6145 } 6146 *v = sv 6147 return nil 6148} 6149 6150func awsAwsjson10_deserializeDocumentDomainInfoList(v *[]types.DomainInfo, value interface{}) error { 6151 if v == nil { 6152 return fmt.Errorf("unexpected nil of type %T", v) 6153 } 6154 if value == nil { 6155 return nil 6156 } 6157 6158 shape, ok := value.([]interface{}) 6159 if !ok { 6160 return fmt.Errorf("unexpected JSON type %v", value) 6161 } 6162 6163 var cv []types.DomainInfo 6164 if *v == nil { 6165 cv = []types.DomainInfo{} 6166 } else { 6167 cv = *v 6168 } 6169 6170 for _, value := range shape { 6171 var col types.DomainInfo 6172 destAddr := &col 6173 if err := awsAwsjson10_deserializeDocumentDomainInfo(&destAddr, value); err != nil { 6174 return err 6175 } 6176 col = *destAddr 6177 cv = append(cv, col) 6178 6179 } 6180 *v = cv 6181 return nil 6182} 6183 6184func awsAwsjson10_deserializeDocumentExternalWorkflowExecutionCancelRequestedEventAttributes(v **types.ExternalWorkflowExecutionCancelRequestedEventAttributes, value interface{}) error { 6185 if v == nil { 6186 return fmt.Errorf("unexpected nil of type %T", v) 6187 } 6188 if value == nil { 6189 return nil 6190 } 6191 6192 shape, ok := value.(map[string]interface{}) 6193 if !ok { 6194 return fmt.Errorf("unexpected JSON type %v", value) 6195 } 6196 6197 var sv *types.ExternalWorkflowExecutionCancelRequestedEventAttributes 6198 if *v == nil { 6199 sv = &types.ExternalWorkflowExecutionCancelRequestedEventAttributes{} 6200 } else { 6201 sv = *v 6202 } 6203 6204 for key, value := range shape { 6205 switch key { 6206 case "initiatedEventId": 6207 if value != nil { 6208 jtv, ok := value.(json.Number) 6209 if !ok { 6210 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 6211 } 6212 i64, err := jtv.Int64() 6213 if err != nil { 6214 return err 6215 } 6216 sv.InitiatedEventId = i64 6217 } 6218 6219 case "workflowExecution": 6220 if err := awsAwsjson10_deserializeDocumentWorkflowExecution(&sv.WorkflowExecution, value); err != nil { 6221 return err 6222 } 6223 6224 default: 6225 _, _ = key, value 6226 6227 } 6228 } 6229 *v = sv 6230 return nil 6231} 6232 6233func awsAwsjson10_deserializeDocumentExternalWorkflowExecutionSignaledEventAttributes(v **types.ExternalWorkflowExecutionSignaledEventAttributes, value interface{}) error { 6234 if v == nil { 6235 return fmt.Errorf("unexpected nil of type %T", v) 6236 } 6237 if value == nil { 6238 return nil 6239 } 6240 6241 shape, ok := value.(map[string]interface{}) 6242 if !ok { 6243 return fmt.Errorf("unexpected JSON type %v", value) 6244 } 6245 6246 var sv *types.ExternalWorkflowExecutionSignaledEventAttributes 6247 if *v == nil { 6248 sv = &types.ExternalWorkflowExecutionSignaledEventAttributes{} 6249 } else { 6250 sv = *v 6251 } 6252 6253 for key, value := range shape { 6254 switch key { 6255 case "initiatedEventId": 6256 if value != nil { 6257 jtv, ok := value.(json.Number) 6258 if !ok { 6259 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 6260 } 6261 i64, err := jtv.Int64() 6262 if err != nil { 6263 return err 6264 } 6265 sv.InitiatedEventId = i64 6266 } 6267 6268 case "workflowExecution": 6269 if err := awsAwsjson10_deserializeDocumentWorkflowExecution(&sv.WorkflowExecution, value); err != nil { 6270 return err 6271 } 6272 6273 default: 6274 _, _ = key, value 6275 6276 } 6277 } 6278 *v = sv 6279 return nil 6280} 6281 6282func awsAwsjson10_deserializeDocumentFailWorkflowExecutionFailedEventAttributes(v **types.FailWorkflowExecutionFailedEventAttributes, value interface{}) error { 6283 if v == nil { 6284 return fmt.Errorf("unexpected nil of type %T", v) 6285 } 6286 if value == nil { 6287 return nil 6288 } 6289 6290 shape, ok := value.(map[string]interface{}) 6291 if !ok { 6292 return fmt.Errorf("unexpected JSON type %v", value) 6293 } 6294 6295 var sv *types.FailWorkflowExecutionFailedEventAttributes 6296 if *v == nil { 6297 sv = &types.FailWorkflowExecutionFailedEventAttributes{} 6298 } else { 6299 sv = *v 6300 } 6301 6302 for key, value := range shape { 6303 switch key { 6304 case "cause": 6305 if value != nil { 6306 jtv, ok := value.(string) 6307 if !ok { 6308 return fmt.Errorf("expected FailWorkflowExecutionFailedCause to be of type string, got %T instead", value) 6309 } 6310 sv.Cause = types.FailWorkflowExecutionFailedCause(jtv) 6311 } 6312 6313 case "decisionTaskCompletedEventId": 6314 if value != nil { 6315 jtv, ok := value.(json.Number) 6316 if !ok { 6317 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 6318 } 6319 i64, err := jtv.Int64() 6320 if err != nil { 6321 return err 6322 } 6323 sv.DecisionTaskCompletedEventId = i64 6324 } 6325 6326 default: 6327 _, _ = key, value 6328 6329 } 6330 } 6331 *v = sv 6332 return nil 6333} 6334 6335func awsAwsjson10_deserializeDocumentHistoryEvent(v **types.HistoryEvent, value interface{}) error { 6336 if v == nil { 6337 return fmt.Errorf("unexpected nil of type %T", v) 6338 } 6339 if value == nil { 6340 return nil 6341 } 6342 6343 shape, ok := value.(map[string]interface{}) 6344 if !ok { 6345 return fmt.Errorf("unexpected JSON type %v", value) 6346 } 6347 6348 var sv *types.HistoryEvent 6349 if *v == nil { 6350 sv = &types.HistoryEvent{} 6351 } else { 6352 sv = *v 6353 } 6354 6355 for key, value := range shape { 6356 switch key { 6357 case "activityTaskCanceledEventAttributes": 6358 if err := awsAwsjson10_deserializeDocumentActivityTaskCanceledEventAttributes(&sv.ActivityTaskCanceledEventAttributes, value); err != nil { 6359 return err 6360 } 6361 6362 case "activityTaskCancelRequestedEventAttributes": 6363 if err := awsAwsjson10_deserializeDocumentActivityTaskCancelRequestedEventAttributes(&sv.ActivityTaskCancelRequestedEventAttributes, value); err != nil { 6364 return err 6365 } 6366 6367 case "activityTaskCompletedEventAttributes": 6368 if err := awsAwsjson10_deserializeDocumentActivityTaskCompletedEventAttributes(&sv.ActivityTaskCompletedEventAttributes, value); err != nil { 6369 return err 6370 } 6371 6372 case "activityTaskFailedEventAttributes": 6373 if err := awsAwsjson10_deserializeDocumentActivityTaskFailedEventAttributes(&sv.ActivityTaskFailedEventAttributes, value); err != nil { 6374 return err 6375 } 6376 6377 case "activityTaskScheduledEventAttributes": 6378 if err := awsAwsjson10_deserializeDocumentActivityTaskScheduledEventAttributes(&sv.ActivityTaskScheduledEventAttributes, value); err != nil { 6379 return err 6380 } 6381 6382 case "activityTaskStartedEventAttributes": 6383 if err := awsAwsjson10_deserializeDocumentActivityTaskStartedEventAttributes(&sv.ActivityTaskStartedEventAttributes, value); err != nil { 6384 return err 6385 } 6386 6387 case "activityTaskTimedOutEventAttributes": 6388 if err := awsAwsjson10_deserializeDocumentActivityTaskTimedOutEventAttributes(&sv.ActivityTaskTimedOutEventAttributes, value); err != nil { 6389 return err 6390 } 6391 6392 case "cancelTimerFailedEventAttributes": 6393 if err := awsAwsjson10_deserializeDocumentCancelTimerFailedEventAttributes(&sv.CancelTimerFailedEventAttributes, value); err != nil { 6394 return err 6395 } 6396 6397 case "cancelWorkflowExecutionFailedEventAttributes": 6398 if err := awsAwsjson10_deserializeDocumentCancelWorkflowExecutionFailedEventAttributes(&sv.CancelWorkflowExecutionFailedEventAttributes, value); err != nil { 6399 return err 6400 } 6401 6402 case "childWorkflowExecutionCanceledEventAttributes": 6403 if err := awsAwsjson10_deserializeDocumentChildWorkflowExecutionCanceledEventAttributes(&sv.ChildWorkflowExecutionCanceledEventAttributes, value); err != nil { 6404 return err 6405 } 6406 6407 case "childWorkflowExecutionCompletedEventAttributes": 6408 if err := awsAwsjson10_deserializeDocumentChildWorkflowExecutionCompletedEventAttributes(&sv.ChildWorkflowExecutionCompletedEventAttributes, value); err != nil { 6409 return err 6410 } 6411 6412 case "childWorkflowExecutionFailedEventAttributes": 6413 if err := awsAwsjson10_deserializeDocumentChildWorkflowExecutionFailedEventAttributes(&sv.ChildWorkflowExecutionFailedEventAttributes, value); err != nil { 6414 return err 6415 } 6416 6417 case "childWorkflowExecutionStartedEventAttributes": 6418 if err := awsAwsjson10_deserializeDocumentChildWorkflowExecutionStartedEventAttributes(&sv.ChildWorkflowExecutionStartedEventAttributes, value); err != nil { 6419 return err 6420 } 6421 6422 case "childWorkflowExecutionTerminatedEventAttributes": 6423 if err := awsAwsjson10_deserializeDocumentChildWorkflowExecutionTerminatedEventAttributes(&sv.ChildWorkflowExecutionTerminatedEventAttributes, value); err != nil { 6424 return err 6425 } 6426 6427 case "childWorkflowExecutionTimedOutEventAttributes": 6428 if err := awsAwsjson10_deserializeDocumentChildWorkflowExecutionTimedOutEventAttributes(&sv.ChildWorkflowExecutionTimedOutEventAttributes, value); err != nil { 6429 return err 6430 } 6431 6432 case "completeWorkflowExecutionFailedEventAttributes": 6433 if err := awsAwsjson10_deserializeDocumentCompleteWorkflowExecutionFailedEventAttributes(&sv.CompleteWorkflowExecutionFailedEventAttributes, value); err != nil { 6434 return err 6435 } 6436 6437 case "continueAsNewWorkflowExecutionFailedEventAttributes": 6438 if err := awsAwsjson10_deserializeDocumentContinueAsNewWorkflowExecutionFailedEventAttributes(&sv.ContinueAsNewWorkflowExecutionFailedEventAttributes, value); err != nil { 6439 return err 6440 } 6441 6442 case "decisionTaskCompletedEventAttributes": 6443 if err := awsAwsjson10_deserializeDocumentDecisionTaskCompletedEventAttributes(&sv.DecisionTaskCompletedEventAttributes, value); err != nil { 6444 return err 6445 } 6446 6447 case "decisionTaskScheduledEventAttributes": 6448 if err := awsAwsjson10_deserializeDocumentDecisionTaskScheduledEventAttributes(&sv.DecisionTaskScheduledEventAttributes, value); err != nil { 6449 return err 6450 } 6451 6452 case "decisionTaskStartedEventAttributes": 6453 if err := awsAwsjson10_deserializeDocumentDecisionTaskStartedEventAttributes(&sv.DecisionTaskStartedEventAttributes, value); err != nil { 6454 return err 6455 } 6456 6457 case "decisionTaskTimedOutEventAttributes": 6458 if err := awsAwsjson10_deserializeDocumentDecisionTaskTimedOutEventAttributes(&sv.DecisionTaskTimedOutEventAttributes, value); err != nil { 6459 return err 6460 } 6461 6462 case "eventId": 6463 if value != nil { 6464 jtv, ok := value.(json.Number) 6465 if !ok { 6466 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 6467 } 6468 i64, err := jtv.Int64() 6469 if err != nil { 6470 return err 6471 } 6472 sv.EventId = i64 6473 } 6474 6475 case "eventTimestamp": 6476 if value != nil { 6477 jtv, ok := value.(json.Number) 6478 if !ok { 6479 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6480 } 6481 f64, err := jtv.Float64() 6482 if err != nil { 6483 return err 6484 } 6485 sv.EventTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6486 } 6487 6488 case "eventType": 6489 if value != nil { 6490 jtv, ok := value.(string) 6491 if !ok { 6492 return fmt.Errorf("expected EventType to be of type string, got %T instead", value) 6493 } 6494 sv.EventType = types.EventType(jtv) 6495 } 6496 6497 case "externalWorkflowExecutionCancelRequestedEventAttributes": 6498 if err := awsAwsjson10_deserializeDocumentExternalWorkflowExecutionCancelRequestedEventAttributes(&sv.ExternalWorkflowExecutionCancelRequestedEventAttributes, value); err != nil { 6499 return err 6500 } 6501 6502 case "externalWorkflowExecutionSignaledEventAttributes": 6503 if err := awsAwsjson10_deserializeDocumentExternalWorkflowExecutionSignaledEventAttributes(&sv.ExternalWorkflowExecutionSignaledEventAttributes, value); err != nil { 6504 return err 6505 } 6506 6507 case "failWorkflowExecutionFailedEventAttributes": 6508 if err := awsAwsjson10_deserializeDocumentFailWorkflowExecutionFailedEventAttributes(&sv.FailWorkflowExecutionFailedEventAttributes, value); err != nil { 6509 return err 6510 } 6511 6512 case "lambdaFunctionCompletedEventAttributes": 6513 if err := awsAwsjson10_deserializeDocumentLambdaFunctionCompletedEventAttributes(&sv.LambdaFunctionCompletedEventAttributes, value); err != nil { 6514 return err 6515 } 6516 6517 case "lambdaFunctionFailedEventAttributes": 6518 if err := awsAwsjson10_deserializeDocumentLambdaFunctionFailedEventAttributes(&sv.LambdaFunctionFailedEventAttributes, value); err != nil { 6519 return err 6520 } 6521 6522 case "lambdaFunctionScheduledEventAttributes": 6523 if err := awsAwsjson10_deserializeDocumentLambdaFunctionScheduledEventAttributes(&sv.LambdaFunctionScheduledEventAttributes, value); err != nil { 6524 return err 6525 } 6526 6527 case "lambdaFunctionStartedEventAttributes": 6528 if err := awsAwsjson10_deserializeDocumentLambdaFunctionStartedEventAttributes(&sv.LambdaFunctionStartedEventAttributes, value); err != nil { 6529 return err 6530 } 6531 6532 case "lambdaFunctionTimedOutEventAttributes": 6533 if err := awsAwsjson10_deserializeDocumentLambdaFunctionTimedOutEventAttributes(&sv.LambdaFunctionTimedOutEventAttributes, value); err != nil { 6534 return err 6535 } 6536 6537 case "markerRecordedEventAttributes": 6538 if err := awsAwsjson10_deserializeDocumentMarkerRecordedEventAttributes(&sv.MarkerRecordedEventAttributes, value); err != nil { 6539 return err 6540 } 6541 6542 case "recordMarkerFailedEventAttributes": 6543 if err := awsAwsjson10_deserializeDocumentRecordMarkerFailedEventAttributes(&sv.RecordMarkerFailedEventAttributes, value); err != nil { 6544 return err 6545 } 6546 6547 case "requestCancelActivityTaskFailedEventAttributes": 6548 if err := awsAwsjson10_deserializeDocumentRequestCancelActivityTaskFailedEventAttributes(&sv.RequestCancelActivityTaskFailedEventAttributes, value); err != nil { 6549 return err 6550 } 6551 6552 case "requestCancelExternalWorkflowExecutionFailedEventAttributes": 6553 if err := awsAwsjson10_deserializeDocumentRequestCancelExternalWorkflowExecutionFailedEventAttributes(&sv.RequestCancelExternalWorkflowExecutionFailedEventAttributes, value); err != nil { 6554 return err 6555 } 6556 6557 case "requestCancelExternalWorkflowExecutionInitiatedEventAttributes": 6558 if err := awsAwsjson10_deserializeDocumentRequestCancelExternalWorkflowExecutionInitiatedEventAttributes(&sv.RequestCancelExternalWorkflowExecutionInitiatedEventAttributes, value); err != nil { 6559 return err 6560 } 6561 6562 case "scheduleActivityTaskFailedEventAttributes": 6563 if err := awsAwsjson10_deserializeDocumentScheduleActivityTaskFailedEventAttributes(&sv.ScheduleActivityTaskFailedEventAttributes, value); err != nil { 6564 return err 6565 } 6566 6567 case "scheduleLambdaFunctionFailedEventAttributes": 6568 if err := awsAwsjson10_deserializeDocumentScheduleLambdaFunctionFailedEventAttributes(&sv.ScheduleLambdaFunctionFailedEventAttributes, value); err != nil { 6569 return err 6570 } 6571 6572 case "signalExternalWorkflowExecutionFailedEventAttributes": 6573 if err := awsAwsjson10_deserializeDocumentSignalExternalWorkflowExecutionFailedEventAttributes(&sv.SignalExternalWorkflowExecutionFailedEventAttributes, value); err != nil { 6574 return err 6575 } 6576 6577 case "signalExternalWorkflowExecutionInitiatedEventAttributes": 6578 if err := awsAwsjson10_deserializeDocumentSignalExternalWorkflowExecutionInitiatedEventAttributes(&sv.SignalExternalWorkflowExecutionInitiatedEventAttributes, value); err != nil { 6579 return err 6580 } 6581 6582 case "startChildWorkflowExecutionFailedEventAttributes": 6583 if err := awsAwsjson10_deserializeDocumentStartChildWorkflowExecutionFailedEventAttributes(&sv.StartChildWorkflowExecutionFailedEventAttributes, value); err != nil { 6584 return err 6585 } 6586 6587 case "startChildWorkflowExecutionInitiatedEventAttributes": 6588 if err := awsAwsjson10_deserializeDocumentStartChildWorkflowExecutionInitiatedEventAttributes(&sv.StartChildWorkflowExecutionInitiatedEventAttributes, value); err != nil { 6589 return err 6590 } 6591 6592 case "startLambdaFunctionFailedEventAttributes": 6593 if err := awsAwsjson10_deserializeDocumentStartLambdaFunctionFailedEventAttributes(&sv.StartLambdaFunctionFailedEventAttributes, value); err != nil { 6594 return err 6595 } 6596 6597 case "startTimerFailedEventAttributes": 6598 if err := awsAwsjson10_deserializeDocumentStartTimerFailedEventAttributes(&sv.StartTimerFailedEventAttributes, value); err != nil { 6599 return err 6600 } 6601 6602 case "timerCanceledEventAttributes": 6603 if err := awsAwsjson10_deserializeDocumentTimerCanceledEventAttributes(&sv.TimerCanceledEventAttributes, value); err != nil { 6604 return err 6605 } 6606 6607 case "timerFiredEventAttributes": 6608 if err := awsAwsjson10_deserializeDocumentTimerFiredEventAttributes(&sv.TimerFiredEventAttributes, value); err != nil { 6609 return err 6610 } 6611 6612 case "timerStartedEventAttributes": 6613 if err := awsAwsjson10_deserializeDocumentTimerStartedEventAttributes(&sv.TimerStartedEventAttributes, value); err != nil { 6614 return err 6615 } 6616 6617 case "workflowExecutionCanceledEventAttributes": 6618 if err := awsAwsjson10_deserializeDocumentWorkflowExecutionCanceledEventAttributes(&sv.WorkflowExecutionCanceledEventAttributes, value); err != nil { 6619 return err 6620 } 6621 6622 case "workflowExecutionCancelRequestedEventAttributes": 6623 if err := awsAwsjson10_deserializeDocumentWorkflowExecutionCancelRequestedEventAttributes(&sv.WorkflowExecutionCancelRequestedEventAttributes, value); err != nil { 6624 return err 6625 } 6626 6627 case "workflowExecutionCompletedEventAttributes": 6628 if err := awsAwsjson10_deserializeDocumentWorkflowExecutionCompletedEventAttributes(&sv.WorkflowExecutionCompletedEventAttributes, value); err != nil { 6629 return err 6630 } 6631 6632 case "workflowExecutionContinuedAsNewEventAttributes": 6633 if err := awsAwsjson10_deserializeDocumentWorkflowExecutionContinuedAsNewEventAttributes(&sv.WorkflowExecutionContinuedAsNewEventAttributes, value); err != nil { 6634 return err 6635 } 6636 6637 case "workflowExecutionFailedEventAttributes": 6638 if err := awsAwsjson10_deserializeDocumentWorkflowExecutionFailedEventAttributes(&sv.WorkflowExecutionFailedEventAttributes, value); err != nil { 6639 return err 6640 } 6641 6642 case "workflowExecutionSignaledEventAttributes": 6643 if err := awsAwsjson10_deserializeDocumentWorkflowExecutionSignaledEventAttributes(&sv.WorkflowExecutionSignaledEventAttributes, value); err != nil { 6644 return err 6645 } 6646 6647 case "workflowExecutionStartedEventAttributes": 6648 if err := awsAwsjson10_deserializeDocumentWorkflowExecutionStartedEventAttributes(&sv.WorkflowExecutionStartedEventAttributes, value); err != nil { 6649 return err 6650 } 6651 6652 case "workflowExecutionTerminatedEventAttributes": 6653 if err := awsAwsjson10_deserializeDocumentWorkflowExecutionTerminatedEventAttributes(&sv.WorkflowExecutionTerminatedEventAttributes, value); err != nil { 6654 return err 6655 } 6656 6657 case "workflowExecutionTimedOutEventAttributes": 6658 if err := awsAwsjson10_deserializeDocumentWorkflowExecutionTimedOutEventAttributes(&sv.WorkflowExecutionTimedOutEventAttributes, value); err != nil { 6659 return err 6660 } 6661 6662 default: 6663 _, _ = key, value 6664 6665 } 6666 } 6667 *v = sv 6668 return nil 6669} 6670 6671func awsAwsjson10_deserializeDocumentHistoryEventList(v *[]types.HistoryEvent, value interface{}) error { 6672 if v == nil { 6673 return fmt.Errorf("unexpected nil of type %T", v) 6674 } 6675 if value == nil { 6676 return nil 6677 } 6678 6679 shape, ok := value.([]interface{}) 6680 if !ok { 6681 return fmt.Errorf("unexpected JSON type %v", value) 6682 } 6683 6684 var cv []types.HistoryEvent 6685 if *v == nil { 6686 cv = []types.HistoryEvent{} 6687 } else { 6688 cv = *v 6689 } 6690 6691 for _, value := range shape { 6692 var col types.HistoryEvent 6693 destAddr := &col 6694 if err := awsAwsjson10_deserializeDocumentHistoryEvent(&destAddr, value); err != nil { 6695 return err 6696 } 6697 col = *destAddr 6698 cv = append(cv, col) 6699 6700 } 6701 *v = cv 6702 return nil 6703} 6704 6705func awsAwsjson10_deserializeDocumentLambdaFunctionCompletedEventAttributes(v **types.LambdaFunctionCompletedEventAttributes, value interface{}) error { 6706 if v == nil { 6707 return fmt.Errorf("unexpected nil of type %T", v) 6708 } 6709 if value == nil { 6710 return nil 6711 } 6712 6713 shape, ok := value.(map[string]interface{}) 6714 if !ok { 6715 return fmt.Errorf("unexpected JSON type %v", value) 6716 } 6717 6718 var sv *types.LambdaFunctionCompletedEventAttributes 6719 if *v == nil { 6720 sv = &types.LambdaFunctionCompletedEventAttributes{} 6721 } else { 6722 sv = *v 6723 } 6724 6725 for key, value := range shape { 6726 switch key { 6727 case "result": 6728 if value != nil { 6729 jtv, ok := value.(string) 6730 if !ok { 6731 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 6732 } 6733 sv.Result = ptr.String(jtv) 6734 } 6735 6736 case "scheduledEventId": 6737 if value != nil { 6738 jtv, ok := value.(json.Number) 6739 if !ok { 6740 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 6741 } 6742 i64, err := jtv.Int64() 6743 if err != nil { 6744 return err 6745 } 6746 sv.ScheduledEventId = i64 6747 } 6748 6749 case "startedEventId": 6750 if value != nil { 6751 jtv, ok := value.(json.Number) 6752 if !ok { 6753 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 6754 } 6755 i64, err := jtv.Int64() 6756 if err != nil { 6757 return err 6758 } 6759 sv.StartedEventId = i64 6760 } 6761 6762 default: 6763 _, _ = key, value 6764 6765 } 6766 } 6767 *v = sv 6768 return nil 6769} 6770 6771func awsAwsjson10_deserializeDocumentLambdaFunctionFailedEventAttributes(v **types.LambdaFunctionFailedEventAttributes, value interface{}) error { 6772 if v == nil { 6773 return fmt.Errorf("unexpected nil of type %T", v) 6774 } 6775 if value == nil { 6776 return nil 6777 } 6778 6779 shape, ok := value.(map[string]interface{}) 6780 if !ok { 6781 return fmt.Errorf("unexpected JSON type %v", value) 6782 } 6783 6784 var sv *types.LambdaFunctionFailedEventAttributes 6785 if *v == nil { 6786 sv = &types.LambdaFunctionFailedEventAttributes{} 6787 } else { 6788 sv = *v 6789 } 6790 6791 for key, value := range shape { 6792 switch key { 6793 case "details": 6794 if value != nil { 6795 jtv, ok := value.(string) 6796 if !ok { 6797 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 6798 } 6799 sv.Details = ptr.String(jtv) 6800 } 6801 6802 case "reason": 6803 if value != nil { 6804 jtv, ok := value.(string) 6805 if !ok { 6806 return fmt.Errorf("expected FailureReason to be of type string, got %T instead", value) 6807 } 6808 sv.Reason = ptr.String(jtv) 6809 } 6810 6811 case "scheduledEventId": 6812 if value != nil { 6813 jtv, ok := value.(json.Number) 6814 if !ok { 6815 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 6816 } 6817 i64, err := jtv.Int64() 6818 if err != nil { 6819 return err 6820 } 6821 sv.ScheduledEventId = i64 6822 } 6823 6824 case "startedEventId": 6825 if value != nil { 6826 jtv, ok := value.(json.Number) 6827 if !ok { 6828 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 6829 } 6830 i64, err := jtv.Int64() 6831 if err != nil { 6832 return err 6833 } 6834 sv.StartedEventId = i64 6835 } 6836 6837 default: 6838 _, _ = key, value 6839 6840 } 6841 } 6842 *v = sv 6843 return nil 6844} 6845 6846func awsAwsjson10_deserializeDocumentLambdaFunctionScheduledEventAttributes(v **types.LambdaFunctionScheduledEventAttributes, value interface{}) error { 6847 if v == nil { 6848 return fmt.Errorf("unexpected nil of type %T", v) 6849 } 6850 if value == nil { 6851 return nil 6852 } 6853 6854 shape, ok := value.(map[string]interface{}) 6855 if !ok { 6856 return fmt.Errorf("unexpected JSON type %v", value) 6857 } 6858 6859 var sv *types.LambdaFunctionScheduledEventAttributes 6860 if *v == nil { 6861 sv = &types.LambdaFunctionScheduledEventAttributes{} 6862 } else { 6863 sv = *v 6864 } 6865 6866 for key, value := range shape { 6867 switch key { 6868 case "control": 6869 if value != nil { 6870 jtv, ok := value.(string) 6871 if !ok { 6872 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 6873 } 6874 sv.Control = ptr.String(jtv) 6875 } 6876 6877 case "decisionTaskCompletedEventId": 6878 if value != nil { 6879 jtv, ok := value.(json.Number) 6880 if !ok { 6881 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 6882 } 6883 i64, err := jtv.Int64() 6884 if err != nil { 6885 return err 6886 } 6887 sv.DecisionTaskCompletedEventId = i64 6888 } 6889 6890 case "id": 6891 if value != nil { 6892 jtv, ok := value.(string) 6893 if !ok { 6894 return fmt.Errorf("expected FunctionId to be of type string, got %T instead", value) 6895 } 6896 sv.Id = ptr.String(jtv) 6897 } 6898 6899 case "input": 6900 if value != nil { 6901 jtv, ok := value.(string) 6902 if !ok { 6903 return fmt.Errorf("expected FunctionInput to be of type string, got %T instead", value) 6904 } 6905 sv.Input = ptr.String(jtv) 6906 } 6907 6908 case "name": 6909 if value != nil { 6910 jtv, ok := value.(string) 6911 if !ok { 6912 return fmt.Errorf("expected FunctionName to be of type string, got %T instead", value) 6913 } 6914 sv.Name = ptr.String(jtv) 6915 } 6916 6917 case "startToCloseTimeout": 6918 if value != nil { 6919 jtv, ok := value.(string) 6920 if !ok { 6921 return fmt.Errorf("expected DurationInSecondsOptional to be of type string, got %T instead", value) 6922 } 6923 sv.StartToCloseTimeout = ptr.String(jtv) 6924 } 6925 6926 default: 6927 _, _ = key, value 6928 6929 } 6930 } 6931 *v = sv 6932 return nil 6933} 6934 6935func awsAwsjson10_deserializeDocumentLambdaFunctionStartedEventAttributes(v **types.LambdaFunctionStartedEventAttributes, 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.LambdaFunctionStartedEventAttributes 6949 if *v == nil { 6950 sv = &types.LambdaFunctionStartedEventAttributes{} 6951 } else { 6952 sv = *v 6953 } 6954 6955 for key, value := range shape { 6956 switch key { 6957 case "scheduledEventId": 6958 if value != nil { 6959 jtv, ok := value.(json.Number) 6960 if !ok { 6961 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 6962 } 6963 i64, err := jtv.Int64() 6964 if err != nil { 6965 return err 6966 } 6967 sv.ScheduledEventId = i64 6968 } 6969 6970 default: 6971 _, _ = key, value 6972 6973 } 6974 } 6975 *v = sv 6976 return nil 6977} 6978 6979func awsAwsjson10_deserializeDocumentLambdaFunctionTimedOutEventAttributes(v **types.LambdaFunctionTimedOutEventAttributes, value interface{}) error { 6980 if v == nil { 6981 return fmt.Errorf("unexpected nil of type %T", v) 6982 } 6983 if value == nil { 6984 return nil 6985 } 6986 6987 shape, ok := value.(map[string]interface{}) 6988 if !ok { 6989 return fmt.Errorf("unexpected JSON type %v", value) 6990 } 6991 6992 var sv *types.LambdaFunctionTimedOutEventAttributes 6993 if *v == nil { 6994 sv = &types.LambdaFunctionTimedOutEventAttributes{} 6995 } else { 6996 sv = *v 6997 } 6998 6999 for key, value := range shape { 7000 switch key { 7001 case "scheduledEventId": 7002 if value != nil { 7003 jtv, ok := value.(json.Number) 7004 if !ok { 7005 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 7006 } 7007 i64, err := jtv.Int64() 7008 if err != nil { 7009 return err 7010 } 7011 sv.ScheduledEventId = i64 7012 } 7013 7014 case "startedEventId": 7015 if value != nil { 7016 jtv, ok := value.(json.Number) 7017 if !ok { 7018 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 7019 } 7020 i64, err := jtv.Int64() 7021 if err != nil { 7022 return err 7023 } 7024 sv.StartedEventId = i64 7025 } 7026 7027 case "timeoutType": 7028 if value != nil { 7029 jtv, ok := value.(string) 7030 if !ok { 7031 return fmt.Errorf("expected LambdaFunctionTimeoutType to be of type string, got %T instead", value) 7032 } 7033 sv.TimeoutType = types.LambdaFunctionTimeoutType(jtv) 7034 } 7035 7036 default: 7037 _, _ = key, value 7038 7039 } 7040 } 7041 *v = sv 7042 return nil 7043} 7044 7045func awsAwsjson10_deserializeDocumentLimitExceededFault(v **types.LimitExceededFault, value interface{}) error { 7046 if v == nil { 7047 return fmt.Errorf("unexpected nil of type %T", v) 7048 } 7049 if value == nil { 7050 return nil 7051 } 7052 7053 shape, ok := value.(map[string]interface{}) 7054 if !ok { 7055 return fmt.Errorf("unexpected JSON type %v", value) 7056 } 7057 7058 var sv *types.LimitExceededFault 7059 if *v == nil { 7060 sv = &types.LimitExceededFault{} 7061 } else { 7062 sv = *v 7063 } 7064 7065 for key, value := range shape { 7066 switch key { 7067 case "message": 7068 if value != nil { 7069 jtv, ok := value.(string) 7070 if !ok { 7071 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 7072 } 7073 sv.Message = ptr.String(jtv) 7074 } 7075 7076 default: 7077 _, _ = key, value 7078 7079 } 7080 } 7081 *v = sv 7082 return nil 7083} 7084 7085func awsAwsjson10_deserializeDocumentMarkerRecordedEventAttributes(v **types.MarkerRecordedEventAttributes, value interface{}) error { 7086 if v == nil { 7087 return fmt.Errorf("unexpected nil of type %T", v) 7088 } 7089 if value == nil { 7090 return nil 7091 } 7092 7093 shape, ok := value.(map[string]interface{}) 7094 if !ok { 7095 return fmt.Errorf("unexpected JSON type %v", value) 7096 } 7097 7098 var sv *types.MarkerRecordedEventAttributes 7099 if *v == nil { 7100 sv = &types.MarkerRecordedEventAttributes{} 7101 } else { 7102 sv = *v 7103 } 7104 7105 for key, value := range shape { 7106 switch key { 7107 case "decisionTaskCompletedEventId": 7108 if value != nil { 7109 jtv, ok := value.(json.Number) 7110 if !ok { 7111 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 7112 } 7113 i64, err := jtv.Int64() 7114 if err != nil { 7115 return err 7116 } 7117 sv.DecisionTaskCompletedEventId = i64 7118 } 7119 7120 case "details": 7121 if value != nil { 7122 jtv, ok := value.(string) 7123 if !ok { 7124 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 7125 } 7126 sv.Details = ptr.String(jtv) 7127 } 7128 7129 case "markerName": 7130 if value != nil { 7131 jtv, ok := value.(string) 7132 if !ok { 7133 return fmt.Errorf("expected MarkerName to be of type string, got %T instead", value) 7134 } 7135 sv.MarkerName = ptr.String(jtv) 7136 } 7137 7138 default: 7139 _, _ = key, value 7140 7141 } 7142 } 7143 *v = sv 7144 return nil 7145} 7146 7147func awsAwsjson10_deserializeDocumentOperationNotPermittedFault(v **types.OperationNotPermittedFault, value interface{}) error { 7148 if v == nil { 7149 return fmt.Errorf("unexpected nil of type %T", v) 7150 } 7151 if value == nil { 7152 return nil 7153 } 7154 7155 shape, ok := value.(map[string]interface{}) 7156 if !ok { 7157 return fmt.Errorf("unexpected JSON type %v", value) 7158 } 7159 7160 var sv *types.OperationNotPermittedFault 7161 if *v == nil { 7162 sv = &types.OperationNotPermittedFault{} 7163 } else { 7164 sv = *v 7165 } 7166 7167 for key, value := range shape { 7168 switch key { 7169 case "message": 7170 if value != nil { 7171 jtv, ok := value.(string) 7172 if !ok { 7173 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 7174 } 7175 sv.Message = ptr.String(jtv) 7176 } 7177 7178 default: 7179 _, _ = key, value 7180 7181 } 7182 } 7183 *v = sv 7184 return nil 7185} 7186 7187func awsAwsjson10_deserializeDocumentRecordMarkerFailedEventAttributes(v **types.RecordMarkerFailedEventAttributes, value interface{}) error { 7188 if v == nil { 7189 return fmt.Errorf("unexpected nil of type %T", v) 7190 } 7191 if value == nil { 7192 return nil 7193 } 7194 7195 shape, ok := value.(map[string]interface{}) 7196 if !ok { 7197 return fmt.Errorf("unexpected JSON type %v", value) 7198 } 7199 7200 var sv *types.RecordMarkerFailedEventAttributes 7201 if *v == nil { 7202 sv = &types.RecordMarkerFailedEventAttributes{} 7203 } else { 7204 sv = *v 7205 } 7206 7207 for key, value := range shape { 7208 switch key { 7209 case "cause": 7210 if value != nil { 7211 jtv, ok := value.(string) 7212 if !ok { 7213 return fmt.Errorf("expected RecordMarkerFailedCause to be of type string, got %T instead", value) 7214 } 7215 sv.Cause = types.RecordMarkerFailedCause(jtv) 7216 } 7217 7218 case "decisionTaskCompletedEventId": 7219 if value != nil { 7220 jtv, ok := value.(json.Number) 7221 if !ok { 7222 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 7223 } 7224 i64, err := jtv.Int64() 7225 if err != nil { 7226 return err 7227 } 7228 sv.DecisionTaskCompletedEventId = i64 7229 } 7230 7231 case "markerName": 7232 if value != nil { 7233 jtv, ok := value.(string) 7234 if !ok { 7235 return fmt.Errorf("expected MarkerName to be of type string, got %T instead", value) 7236 } 7237 sv.MarkerName = ptr.String(jtv) 7238 } 7239 7240 default: 7241 _, _ = key, value 7242 7243 } 7244 } 7245 *v = sv 7246 return nil 7247} 7248 7249func awsAwsjson10_deserializeDocumentRequestCancelActivityTaskFailedEventAttributes(v **types.RequestCancelActivityTaskFailedEventAttributes, value interface{}) error { 7250 if v == nil { 7251 return fmt.Errorf("unexpected nil of type %T", v) 7252 } 7253 if value == nil { 7254 return nil 7255 } 7256 7257 shape, ok := value.(map[string]interface{}) 7258 if !ok { 7259 return fmt.Errorf("unexpected JSON type %v", value) 7260 } 7261 7262 var sv *types.RequestCancelActivityTaskFailedEventAttributes 7263 if *v == nil { 7264 sv = &types.RequestCancelActivityTaskFailedEventAttributes{} 7265 } else { 7266 sv = *v 7267 } 7268 7269 for key, value := range shape { 7270 switch key { 7271 case "activityId": 7272 if value != nil { 7273 jtv, ok := value.(string) 7274 if !ok { 7275 return fmt.Errorf("expected ActivityId to be of type string, got %T instead", value) 7276 } 7277 sv.ActivityId = ptr.String(jtv) 7278 } 7279 7280 case "cause": 7281 if value != nil { 7282 jtv, ok := value.(string) 7283 if !ok { 7284 return fmt.Errorf("expected RequestCancelActivityTaskFailedCause to be of type string, got %T instead", value) 7285 } 7286 sv.Cause = types.RequestCancelActivityTaskFailedCause(jtv) 7287 } 7288 7289 case "decisionTaskCompletedEventId": 7290 if value != nil { 7291 jtv, ok := value.(json.Number) 7292 if !ok { 7293 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 7294 } 7295 i64, err := jtv.Int64() 7296 if err != nil { 7297 return err 7298 } 7299 sv.DecisionTaskCompletedEventId = i64 7300 } 7301 7302 default: 7303 _, _ = key, value 7304 7305 } 7306 } 7307 *v = sv 7308 return nil 7309} 7310 7311func awsAwsjson10_deserializeDocumentRequestCancelExternalWorkflowExecutionFailedEventAttributes(v **types.RequestCancelExternalWorkflowExecutionFailedEventAttributes, value interface{}) error { 7312 if v == nil { 7313 return fmt.Errorf("unexpected nil of type %T", v) 7314 } 7315 if value == nil { 7316 return nil 7317 } 7318 7319 shape, ok := value.(map[string]interface{}) 7320 if !ok { 7321 return fmt.Errorf("unexpected JSON type %v", value) 7322 } 7323 7324 var sv *types.RequestCancelExternalWorkflowExecutionFailedEventAttributes 7325 if *v == nil { 7326 sv = &types.RequestCancelExternalWorkflowExecutionFailedEventAttributes{} 7327 } else { 7328 sv = *v 7329 } 7330 7331 for key, value := range shape { 7332 switch key { 7333 case "cause": 7334 if value != nil { 7335 jtv, ok := value.(string) 7336 if !ok { 7337 return fmt.Errorf("expected RequestCancelExternalWorkflowExecutionFailedCause to be of type string, got %T instead", value) 7338 } 7339 sv.Cause = types.RequestCancelExternalWorkflowExecutionFailedCause(jtv) 7340 } 7341 7342 case "control": 7343 if value != nil { 7344 jtv, ok := value.(string) 7345 if !ok { 7346 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 7347 } 7348 sv.Control = ptr.String(jtv) 7349 } 7350 7351 case "decisionTaskCompletedEventId": 7352 if value != nil { 7353 jtv, ok := value.(json.Number) 7354 if !ok { 7355 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 7356 } 7357 i64, err := jtv.Int64() 7358 if err != nil { 7359 return err 7360 } 7361 sv.DecisionTaskCompletedEventId = i64 7362 } 7363 7364 case "initiatedEventId": 7365 if value != nil { 7366 jtv, ok := value.(json.Number) 7367 if !ok { 7368 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 7369 } 7370 i64, err := jtv.Int64() 7371 if err != nil { 7372 return err 7373 } 7374 sv.InitiatedEventId = i64 7375 } 7376 7377 case "runId": 7378 if value != nil { 7379 jtv, ok := value.(string) 7380 if !ok { 7381 return fmt.Errorf("expected WorkflowRunIdOptional to be of type string, got %T instead", value) 7382 } 7383 sv.RunId = ptr.String(jtv) 7384 } 7385 7386 case "workflowId": 7387 if value != nil { 7388 jtv, ok := value.(string) 7389 if !ok { 7390 return fmt.Errorf("expected WorkflowId to be of type string, got %T instead", value) 7391 } 7392 sv.WorkflowId = ptr.String(jtv) 7393 } 7394 7395 default: 7396 _, _ = key, value 7397 7398 } 7399 } 7400 *v = sv 7401 return nil 7402} 7403 7404func awsAwsjson10_deserializeDocumentRequestCancelExternalWorkflowExecutionInitiatedEventAttributes(v **types.RequestCancelExternalWorkflowExecutionInitiatedEventAttributes, value interface{}) error { 7405 if v == nil { 7406 return fmt.Errorf("unexpected nil of type %T", v) 7407 } 7408 if value == nil { 7409 return nil 7410 } 7411 7412 shape, ok := value.(map[string]interface{}) 7413 if !ok { 7414 return fmt.Errorf("unexpected JSON type %v", value) 7415 } 7416 7417 var sv *types.RequestCancelExternalWorkflowExecutionInitiatedEventAttributes 7418 if *v == nil { 7419 sv = &types.RequestCancelExternalWorkflowExecutionInitiatedEventAttributes{} 7420 } else { 7421 sv = *v 7422 } 7423 7424 for key, value := range shape { 7425 switch key { 7426 case "control": 7427 if value != nil { 7428 jtv, ok := value.(string) 7429 if !ok { 7430 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 7431 } 7432 sv.Control = ptr.String(jtv) 7433 } 7434 7435 case "decisionTaskCompletedEventId": 7436 if value != nil { 7437 jtv, ok := value.(json.Number) 7438 if !ok { 7439 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 7440 } 7441 i64, err := jtv.Int64() 7442 if err != nil { 7443 return err 7444 } 7445 sv.DecisionTaskCompletedEventId = i64 7446 } 7447 7448 case "runId": 7449 if value != nil { 7450 jtv, ok := value.(string) 7451 if !ok { 7452 return fmt.Errorf("expected WorkflowRunIdOptional to be of type string, got %T instead", value) 7453 } 7454 sv.RunId = ptr.String(jtv) 7455 } 7456 7457 case "workflowId": 7458 if value != nil { 7459 jtv, ok := value.(string) 7460 if !ok { 7461 return fmt.Errorf("expected WorkflowId to be of type string, got %T instead", value) 7462 } 7463 sv.WorkflowId = ptr.String(jtv) 7464 } 7465 7466 default: 7467 _, _ = key, value 7468 7469 } 7470 } 7471 *v = sv 7472 return nil 7473} 7474 7475func awsAwsjson10_deserializeDocumentResourceTag(v **types.ResourceTag, value interface{}) error { 7476 if v == nil { 7477 return fmt.Errorf("unexpected nil of type %T", v) 7478 } 7479 if value == nil { 7480 return nil 7481 } 7482 7483 shape, ok := value.(map[string]interface{}) 7484 if !ok { 7485 return fmt.Errorf("unexpected JSON type %v", value) 7486 } 7487 7488 var sv *types.ResourceTag 7489 if *v == nil { 7490 sv = &types.ResourceTag{} 7491 } else { 7492 sv = *v 7493 } 7494 7495 for key, value := range shape { 7496 switch key { 7497 case "key": 7498 if value != nil { 7499 jtv, ok := value.(string) 7500 if !ok { 7501 return fmt.Errorf("expected ResourceTagKey to be of type string, got %T instead", value) 7502 } 7503 sv.Key = ptr.String(jtv) 7504 } 7505 7506 case "value": 7507 if value != nil { 7508 jtv, ok := value.(string) 7509 if !ok { 7510 return fmt.Errorf("expected ResourceTagValue to be of type string, got %T instead", value) 7511 } 7512 sv.Value = ptr.String(jtv) 7513 } 7514 7515 default: 7516 _, _ = key, value 7517 7518 } 7519 } 7520 *v = sv 7521 return nil 7522} 7523 7524func awsAwsjson10_deserializeDocumentResourceTagList(v *[]types.ResourceTag, value interface{}) error { 7525 if v == nil { 7526 return fmt.Errorf("unexpected nil of type %T", v) 7527 } 7528 if value == nil { 7529 return nil 7530 } 7531 7532 shape, ok := value.([]interface{}) 7533 if !ok { 7534 return fmt.Errorf("unexpected JSON type %v", value) 7535 } 7536 7537 var cv []types.ResourceTag 7538 if *v == nil { 7539 cv = []types.ResourceTag{} 7540 } else { 7541 cv = *v 7542 } 7543 7544 for _, value := range shape { 7545 var col types.ResourceTag 7546 destAddr := &col 7547 if err := awsAwsjson10_deserializeDocumentResourceTag(&destAddr, value); err != nil { 7548 return err 7549 } 7550 col = *destAddr 7551 cv = append(cv, col) 7552 7553 } 7554 *v = cv 7555 return nil 7556} 7557 7558func awsAwsjson10_deserializeDocumentScheduleActivityTaskFailedEventAttributes(v **types.ScheduleActivityTaskFailedEventAttributes, value interface{}) error { 7559 if v == nil { 7560 return fmt.Errorf("unexpected nil of type %T", v) 7561 } 7562 if value == nil { 7563 return nil 7564 } 7565 7566 shape, ok := value.(map[string]interface{}) 7567 if !ok { 7568 return fmt.Errorf("unexpected JSON type %v", value) 7569 } 7570 7571 var sv *types.ScheduleActivityTaskFailedEventAttributes 7572 if *v == nil { 7573 sv = &types.ScheduleActivityTaskFailedEventAttributes{} 7574 } else { 7575 sv = *v 7576 } 7577 7578 for key, value := range shape { 7579 switch key { 7580 case "activityId": 7581 if value != nil { 7582 jtv, ok := value.(string) 7583 if !ok { 7584 return fmt.Errorf("expected ActivityId to be of type string, got %T instead", value) 7585 } 7586 sv.ActivityId = ptr.String(jtv) 7587 } 7588 7589 case "activityType": 7590 if err := awsAwsjson10_deserializeDocumentActivityType(&sv.ActivityType, value); err != nil { 7591 return err 7592 } 7593 7594 case "cause": 7595 if value != nil { 7596 jtv, ok := value.(string) 7597 if !ok { 7598 return fmt.Errorf("expected ScheduleActivityTaskFailedCause to be of type string, got %T instead", value) 7599 } 7600 sv.Cause = types.ScheduleActivityTaskFailedCause(jtv) 7601 } 7602 7603 case "decisionTaskCompletedEventId": 7604 if value != nil { 7605 jtv, ok := value.(json.Number) 7606 if !ok { 7607 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 7608 } 7609 i64, err := jtv.Int64() 7610 if err != nil { 7611 return err 7612 } 7613 sv.DecisionTaskCompletedEventId = i64 7614 } 7615 7616 default: 7617 _, _ = key, value 7618 7619 } 7620 } 7621 *v = sv 7622 return nil 7623} 7624 7625func awsAwsjson10_deserializeDocumentScheduleLambdaFunctionFailedEventAttributes(v **types.ScheduleLambdaFunctionFailedEventAttributes, value interface{}) error { 7626 if v == nil { 7627 return fmt.Errorf("unexpected nil of type %T", v) 7628 } 7629 if value == nil { 7630 return nil 7631 } 7632 7633 shape, ok := value.(map[string]interface{}) 7634 if !ok { 7635 return fmt.Errorf("unexpected JSON type %v", value) 7636 } 7637 7638 var sv *types.ScheduleLambdaFunctionFailedEventAttributes 7639 if *v == nil { 7640 sv = &types.ScheduleLambdaFunctionFailedEventAttributes{} 7641 } else { 7642 sv = *v 7643 } 7644 7645 for key, value := range shape { 7646 switch key { 7647 case "cause": 7648 if value != nil { 7649 jtv, ok := value.(string) 7650 if !ok { 7651 return fmt.Errorf("expected ScheduleLambdaFunctionFailedCause to be of type string, got %T instead", value) 7652 } 7653 sv.Cause = types.ScheduleLambdaFunctionFailedCause(jtv) 7654 } 7655 7656 case "decisionTaskCompletedEventId": 7657 if value != nil { 7658 jtv, ok := value.(json.Number) 7659 if !ok { 7660 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 7661 } 7662 i64, err := jtv.Int64() 7663 if err != nil { 7664 return err 7665 } 7666 sv.DecisionTaskCompletedEventId = i64 7667 } 7668 7669 case "id": 7670 if value != nil { 7671 jtv, ok := value.(string) 7672 if !ok { 7673 return fmt.Errorf("expected FunctionId to be of type string, got %T instead", value) 7674 } 7675 sv.Id = ptr.String(jtv) 7676 } 7677 7678 case "name": 7679 if value != nil { 7680 jtv, ok := value.(string) 7681 if !ok { 7682 return fmt.Errorf("expected FunctionName to be of type string, got %T instead", value) 7683 } 7684 sv.Name = ptr.String(jtv) 7685 } 7686 7687 default: 7688 _, _ = key, value 7689 7690 } 7691 } 7692 *v = sv 7693 return nil 7694} 7695 7696func awsAwsjson10_deserializeDocumentSignalExternalWorkflowExecutionFailedEventAttributes(v **types.SignalExternalWorkflowExecutionFailedEventAttributes, value interface{}) error { 7697 if v == nil { 7698 return fmt.Errorf("unexpected nil of type %T", v) 7699 } 7700 if value == nil { 7701 return nil 7702 } 7703 7704 shape, ok := value.(map[string]interface{}) 7705 if !ok { 7706 return fmt.Errorf("unexpected JSON type %v", value) 7707 } 7708 7709 var sv *types.SignalExternalWorkflowExecutionFailedEventAttributes 7710 if *v == nil { 7711 sv = &types.SignalExternalWorkflowExecutionFailedEventAttributes{} 7712 } else { 7713 sv = *v 7714 } 7715 7716 for key, value := range shape { 7717 switch key { 7718 case "cause": 7719 if value != nil { 7720 jtv, ok := value.(string) 7721 if !ok { 7722 return fmt.Errorf("expected SignalExternalWorkflowExecutionFailedCause to be of type string, got %T instead", value) 7723 } 7724 sv.Cause = types.SignalExternalWorkflowExecutionFailedCause(jtv) 7725 } 7726 7727 case "control": 7728 if value != nil { 7729 jtv, ok := value.(string) 7730 if !ok { 7731 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 7732 } 7733 sv.Control = ptr.String(jtv) 7734 } 7735 7736 case "decisionTaskCompletedEventId": 7737 if value != nil { 7738 jtv, ok := value.(json.Number) 7739 if !ok { 7740 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 7741 } 7742 i64, err := jtv.Int64() 7743 if err != nil { 7744 return err 7745 } 7746 sv.DecisionTaskCompletedEventId = i64 7747 } 7748 7749 case "initiatedEventId": 7750 if value != nil { 7751 jtv, ok := value.(json.Number) 7752 if !ok { 7753 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 7754 } 7755 i64, err := jtv.Int64() 7756 if err != nil { 7757 return err 7758 } 7759 sv.InitiatedEventId = i64 7760 } 7761 7762 case "runId": 7763 if value != nil { 7764 jtv, ok := value.(string) 7765 if !ok { 7766 return fmt.Errorf("expected WorkflowRunIdOptional to be of type string, got %T instead", value) 7767 } 7768 sv.RunId = ptr.String(jtv) 7769 } 7770 7771 case "workflowId": 7772 if value != nil { 7773 jtv, ok := value.(string) 7774 if !ok { 7775 return fmt.Errorf("expected WorkflowId to be of type string, got %T instead", value) 7776 } 7777 sv.WorkflowId = ptr.String(jtv) 7778 } 7779 7780 default: 7781 _, _ = key, value 7782 7783 } 7784 } 7785 *v = sv 7786 return nil 7787} 7788 7789func awsAwsjson10_deserializeDocumentSignalExternalWorkflowExecutionInitiatedEventAttributes(v **types.SignalExternalWorkflowExecutionInitiatedEventAttributes, value interface{}) error { 7790 if v == nil { 7791 return fmt.Errorf("unexpected nil of type %T", v) 7792 } 7793 if value == nil { 7794 return nil 7795 } 7796 7797 shape, ok := value.(map[string]interface{}) 7798 if !ok { 7799 return fmt.Errorf("unexpected JSON type %v", value) 7800 } 7801 7802 var sv *types.SignalExternalWorkflowExecutionInitiatedEventAttributes 7803 if *v == nil { 7804 sv = &types.SignalExternalWorkflowExecutionInitiatedEventAttributes{} 7805 } else { 7806 sv = *v 7807 } 7808 7809 for key, value := range shape { 7810 switch key { 7811 case "control": 7812 if value != nil { 7813 jtv, ok := value.(string) 7814 if !ok { 7815 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 7816 } 7817 sv.Control = ptr.String(jtv) 7818 } 7819 7820 case "decisionTaskCompletedEventId": 7821 if value != nil { 7822 jtv, ok := value.(json.Number) 7823 if !ok { 7824 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 7825 } 7826 i64, err := jtv.Int64() 7827 if err != nil { 7828 return err 7829 } 7830 sv.DecisionTaskCompletedEventId = i64 7831 } 7832 7833 case "input": 7834 if value != nil { 7835 jtv, ok := value.(string) 7836 if !ok { 7837 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 7838 } 7839 sv.Input = ptr.String(jtv) 7840 } 7841 7842 case "runId": 7843 if value != nil { 7844 jtv, ok := value.(string) 7845 if !ok { 7846 return fmt.Errorf("expected WorkflowRunIdOptional to be of type string, got %T instead", value) 7847 } 7848 sv.RunId = ptr.String(jtv) 7849 } 7850 7851 case "signalName": 7852 if value != nil { 7853 jtv, ok := value.(string) 7854 if !ok { 7855 return fmt.Errorf("expected SignalName to be of type string, got %T instead", value) 7856 } 7857 sv.SignalName = ptr.String(jtv) 7858 } 7859 7860 case "workflowId": 7861 if value != nil { 7862 jtv, ok := value.(string) 7863 if !ok { 7864 return fmt.Errorf("expected WorkflowId to be of type string, got %T instead", value) 7865 } 7866 sv.WorkflowId = ptr.String(jtv) 7867 } 7868 7869 default: 7870 _, _ = key, value 7871 7872 } 7873 } 7874 *v = sv 7875 return nil 7876} 7877 7878func awsAwsjson10_deserializeDocumentStartChildWorkflowExecutionFailedEventAttributes(v **types.StartChildWorkflowExecutionFailedEventAttributes, value interface{}) error { 7879 if v == nil { 7880 return fmt.Errorf("unexpected nil of type %T", v) 7881 } 7882 if value == nil { 7883 return nil 7884 } 7885 7886 shape, ok := value.(map[string]interface{}) 7887 if !ok { 7888 return fmt.Errorf("unexpected JSON type %v", value) 7889 } 7890 7891 var sv *types.StartChildWorkflowExecutionFailedEventAttributes 7892 if *v == nil { 7893 sv = &types.StartChildWorkflowExecutionFailedEventAttributes{} 7894 } else { 7895 sv = *v 7896 } 7897 7898 for key, value := range shape { 7899 switch key { 7900 case "cause": 7901 if value != nil { 7902 jtv, ok := value.(string) 7903 if !ok { 7904 return fmt.Errorf("expected StartChildWorkflowExecutionFailedCause to be of type string, got %T instead", value) 7905 } 7906 sv.Cause = types.StartChildWorkflowExecutionFailedCause(jtv) 7907 } 7908 7909 case "control": 7910 if value != nil { 7911 jtv, ok := value.(string) 7912 if !ok { 7913 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 7914 } 7915 sv.Control = ptr.String(jtv) 7916 } 7917 7918 case "decisionTaskCompletedEventId": 7919 if value != nil { 7920 jtv, ok := value.(json.Number) 7921 if !ok { 7922 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 7923 } 7924 i64, err := jtv.Int64() 7925 if err != nil { 7926 return err 7927 } 7928 sv.DecisionTaskCompletedEventId = i64 7929 } 7930 7931 case "initiatedEventId": 7932 if value != nil { 7933 jtv, ok := value.(json.Number) 7934 if !ok { 7935 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 7936 } 7937 i64, err := jtv.Int64() 7938 if err != nil { 7939 return err 7940 } 7941 sv.InitiatedEventId = i64 7942 } 7943 7944 case "workflowId": 7945 if value != nil { 7946 jtv, ok := value.(string) 7947 if !ok { 7948 return fmt.Errorf("expected WorkflowId to be of type string, got %T instead", value) 7949 } 7950 sv.WorkflowId = ptr.String(jtv) 7951 } 7952 7953 case "workflowType": 7954 if err := awsAwsjson10_deserializeDocumentWorkflowType(&sv.WorkflowType, value); err != nil { 7955 return err 7956 } 7957 7958 default: 7959 _, _ = key, value 7960 7961 } 7962 } 7963 *v = sv 7964 return nil 7965} 7966 7967func awsAwsjson10_deserializeDocumentStartChildWorkflowExecutionInitiatedEventAttributes(v **types.StartChildWorkflowExecutionInitiatedEventAttributes, value interface{}) error { 7968 if v == nil { 7969 return fmt.Errorf("unexpected nil of type %T", v) 7970 } 7971 if value == nil { 7972 return nil 7973 } 7974 7975 shape, ok := value.(map[string]interface{}) 7976 if !ok { 7977 return fmt.Errorf("unexpected JSON type %v", value) 7978 } 7979 7980 var sv *types.StartChildWorkflowExecutionInitiatedEventAttributes 7981 if *v == nil { 7982 sv = &types.StartChildWorkflowExecutionInitiatedEventAttributes{} 7983 } else { 7984 sv = *v 7985 } 7986 7987 for key, value := range shape { 7988 switch key { 7989 case "childPolicy": 7990 if value != nil { 7991 jtv, ok := value.(string) 7992 if !ok { 7993 return fmt.Errorf("expected ChildPolicy to be of type string, got %T instead", value) 7994 } 7995 sv.ChildPolicy = types.ChildPolicy(jtv) 7996 } 7997 7998 case "control": 7999 if value != nil { 8000 jtv, ok := value.(string) 8001 if !ok { 8002 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 8003 } 8004 sv.Control = ptr.String(jtv) 8005 } 8006 8007 case "decisionTaskCompletedEventId": 8008 if value != nil { 8009 jtv, ok := value.(json.Number) 8010 if !ok { 8011 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 8012 } 8013 i64, err := jtv.Int64() 8014 if err != nil { 8015 return err 8016 } 8017 sv.DecisionTaskCompletedEventId = i64 8018 } 8019 8020 case "executionStartToCloseTimeout": 8021 if value != nil { 8022 jtv, ok := value.(string) 8023 if !ok { 8024 return fmt.Errorf("expected DurationInSecondsOptional to be of type string, got %T instead", value) 8025 } 8026 sv.ExecutionStartToCloseTimeout = ptr.String(jtv) 8027 } 8028 8029 case "input": 8030 if value != nil { 8031 jtv, ok := value.(string) 8032 if !ok { 8033 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 8034 } 8035 sv.Input = ptr.String(jtv) 8036 } 8037 8038 case "lambdaRole": 8039 if value != nil { 8040 jtv, ok := value.(string) 8041 if !ok { 8042 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 8043 } 8044 sv.LambdaRole = ptr.String(jtv) 8045 } 8046 8047 case "tagList": 8048 if err := awsAwsjson10_deserializeDocumentTagList(&sv.TagList, value); err != nil { 8049 return err 8050 } 8051 8052 case "taskList": 8053 if err := awsAwsjson10_deserializeDocumentTaskList(&sv.TaskList, value); err != nil { 8054 return err 8055 } 8056 8057 case "taskPriority": 8058 if value != nil { 8059 jtv, ok := value.(string) 8060 if !ok { 8061 return fmt.Errorf("expected TaskPriority to be of type string, got %T instead", value) 8062 } 8063 sv.TaskPriority = ptr.String(jtv) 8064 } 8065 8066 case "taskStartToCloseTimeout": 8067 if value != nil { 8068 jtv, ok := value.(string) 8069 if !ok { 8070 return fmt.Errorf("expected DurationInSecondsOptional to be of type string, got %T instead", value) 8071 } 8072 sv.TaskStartToCloseTimeout = ptr.String(jtv) 8073 } 8074 8075 case "workflowId": 8076 if value != nil { 8077 jtv, ok := value.(string) 8078 if !ok { 8079 return fmt.Errorf("expected WorkflowId to be of type string, got %T instead", value) 8080 } 8081 sv.WorkflowId = ptr.String(jtv) 8082 } 8083 8084 case "workflowType": 8085 if err := awsAwsjson10_deserializeDocumentWorkflowType(&sv.WorkflowType, value); err != nil { 8086 return err 8087 } 8088 8089 default: 8090 _, _ = key, value 8091 8092 } 8093 } 8094 *v = sv 8095 return nil 8096} 8097 8098func awsAwsjson10_deserializeDocumentStartLambdaFunctionFailedEventAttributes(v **types.StartLambdaFunctionFailedEventAttributes, value interface{}) error { 8099 if v == nil { 8100 return fmt.Errorf("unexpected nil of type %T", v) 8101 } 8102 if value == nil { 8103 return nil 8104 } 8105 8106 shape, ok := value.(map[string]interface{}) 8107 if !ok { 8108 return fmt.Errorf("unexpected JSON type %v", value) 8109 } 8110 8111 var sv *types.StartLambdaFunctionFailedEventAttributes 8112 if *v == nil { 8113 sv = &types.StartLambdaFunctionFailedEventAttributes{} 8114 } else { 8115 sv = *v 8116 } 8117 8118 for key, value := range shape { 8119 switch key { 8120 case "cause": 8121 if value != nil { 8122 jtv, ok := value.(string) 8123 if !ok { 8124 return fmt.Errorf("expected StartLambdaFunctionFailedCause to be of type string, got %T instead", value) 8125 } 8126 sv.Cause = types.StartLambdaFunctionFailedCause(jtv) 8127 } 8128 8129 case "message": 8130 if value != nil { 8131 jtv, ok := value.(string) 8132 if !ok { 8133 return fmt.Errorf("expected CauseMessage to be of type string, got %T instead", value) 8134 } 8135 sv.Message = ptr.String(jtv) 8136 } 8137 8138 case "scheduledEventId": 8139 if value != nil { 8140 jtv, ok := value.(json.Number) 8141 if !ok { 8142 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 8143 } 8144 i64, err := jtv.Int64() 8145 if err != nil { 8146 return err 8147 } 8148 sv.ScheduledEventId = i64 8149 } 8150 8151 default: 8152 _, _ = key, value 8153 8154 } 8155 } 8156 *v = sv 8157 return nil 8158} 8159 8160func awsAwsjson10_deserializeDocumentStartTimerFailedEventAttributes(v **types.StartTimerFailedEventAttributes, value interface{}) error { 8161 if v == nil { 8162 return fmt.Errorf("unexpected nil of type %T", v) 8163 } 8164 if value == nil { 8165 return nil 8166 } 8167 8168 shape, ok := value.(map[string]interface{}) 8169 if !ok { 8170 return fmt.Errorf("unexpected JSON type %v", value) 8171 } 8172 8173 var sv *types.StartTimerFailedEventAttributes 8174 if *v == nil { 8175 sv = &types.StartTimerFailedEventAttributes{} 8176 } else { 8177 sv = *v 8178 } 8179 8180 for key, value := range shape { 8181 switch key { 8182 case "cause": 8183 if value != nil { 8184 jtv, ok := value.(string) 8185 if !ok { 8186 return fmt.Errorf("expected StartTimerFailedCause to be of type string, got %T instead", value) 8187 } 8188 sv.Cause = types.StartTimerFailedCause(jtv) 8189 } 8190 8191 case "decisionTaskCompletedEventId": 8192 if value != nil { 8193 jtv, ok := value.(json.Number) 8194 if !ok { 8195 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 8196 } 8197 i64, err := jtv.Int64() 8198 if err != nil { 8199 return err 8200 } 8201 sv.DecisionTaskCompletedEventId = i64 8202 } 8203 8204 case "timerId": 8205 if value != nil { 8206 jtv, ok := value.(string) 8207 if !ok { 8208 return fmt.Errorf("expected TimerId to be of type string, got %T instead", value) 8209 } 8210 sv.TimerId = ptr.String(jtv) 8211 } 8212 8213 default: 8214 _, _ = key, value 8215 8216 } 8217 } 8218 *v = sv 8219 return nil 8220} 8221 8222func awsAwsjson10_deserializeDocumentTagList(v *[]string, value interface{}) error { 8223 if v == nil { 8224 return fmt.Errorf("unexpected nil of type %T", v) 8225 } 8226 if value == nil { 8227 return nil 8228 } 8229 8230 shape, ok := value.([]interface{}) 8231 if !ok { 8232 return fmt.Errorf("unexpected JSON type %v", value) 8233 } 8234 8235 var cv []string 8236 if *v == nil { 8237 cv = []string{} 8238 } else { 8239 cv = *v 8240 } 8241 8242 for _, value := range shape { 8243 var col string 8244 if value != nil { 8245 jtv, ok := value.(string) 8246 if !ok { 8247 return fmt.Errorf("expected Tag to be of type string, got %T instead", value) 8248 } 8249 col = jtv 8250 } 8251 cv = append(cv, col) 8252 8253 } 8254 *v = cv 8255 return nil 8256} 8257 8258func awsAwsjson10_deserializeDocumentTaskList(v **types.TaskList, value interface{}) error { 8259 if v == nil { 8260 return fmt.Errorf("unexpected nil of type %T", v) 8261 } 8262 if value == nil { 8263 return nil 8264 } 8265 8266 shape, ok := value.(map[string]interface{}) 8267 if !ok { 8268 return fmt.Errorf("unexpected JSON type %v", value) 8269 } 8270 8271 var sv *types.TaskList 8272 if *v == nil { 8273 sv = &types.TaskList{} 8274 } else { 8275 sv = *v 8276 } 8277 8278 for key, value := range shape { 8279 switch key { 8280 case "name": 8281 if value != nil { 8282 jtv, ok := value.(string) 8283 if !ok { 8284 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 8285 } 8286 sv.Name = ptr.String(jtv) 8287 } 8288 8289 default: 8290 _, _ = key, value 8291 8292 } 8293 } 8294 *v = sv 8295 return nil 8296} 8297 8298func awsAwsjson10_deserializeDocumentTimerCanceledEventAttributes(v **types.TimerCanceledEventAttributes, value interface{}) error { 8299 if v == nil { 8300 return fmt.Errorf("unexpected nil of type %T", v) 8301 } 8302 if value == nil { 8303 return nil 8304 } 8305 8306 shape, ok := value.(map[string]interface{}) 8307 if !ok { 8308 return fmt.Errorf("unexpected JSON type %v", value) 8309 } 8310 8311 var sv *types.TimerCanceledEventAttributes 8312 if *v == nil { 8313 sv = &types.TimerCanceledEventAttributes{} 8314 } else { 8315 sv = *v 8316 } 8317 8318 for key, value := range shape { 8319 switch key { 8320 case "decisionTaskCompletedEventId": 8321 if value != nil { 8322 jtv, ok := value.(json.Number) 8323 if !ok { 8324 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 8325 } 8326 i64, err := jtv.Int64() 8327 if err != nil { 8328 return err 8329 } 8330 sv.DecisionTaskCompletedEventId = i64 8331 } 8332 8333 case "startedEventId": 8334 if value != nil { 8335 jtv, ok := value.(json.Number) 8336 if !ok { 8337 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 8338 } 8339 i64, err := jtv.Int64() 8340 if err != nil { 8341 return err 8342 } 8343 sv.StartedEventId = i64 8344 } 8345 8346 case "timerId": 8347 if value != nil { 8348 jtv, ok := value.(string) 8349 if !ok { 8350 return fmt.Errorf("expected TimerId to be of type string, got %T instead", value) 8351 } 8352 sv.TimerId = ptr.String(jtv) 8353 } 8354 8355 default: 8356 _, _ = key, value 8357 8358 } 8359 } 8360 *v = sv 8361 return nil 8362} 8363 8364func awsAwsjson10_deserializeDocumentTimerFiredEventAttributes(v **types.TimerFiredEventAttributes, value interface{}) error { 8365 if v == nil { 8366 return fmt.Errorf("unexpected nil of type %T", v) 8367 } 8368 if value == nil { 8369 return nil 8370 } 8371 8372 shape, ok := value.(map[string]interface{}) 8373 if !ok { 8374 return fmt.Errorf("unexpected JSON type %v", value) 8375 } 8376 8377 var sv *types.TimerFiredEventAttributes 8378 if *v == nil { 8379 sv = &types.TimerFiredEventAttributes{} 8380 } else { 8381 sv = *v 8382 } 8383 8384 for key, value := range shape { 8385 switch key { 8386 case "startedEventId": 8387 if value != nil { 8388 jtv, ok := value.(json.Number) 8389 if !ok { 8390 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 8391 } 8392 i64, err := jtv.Int64() 8393 if err != nil { 8394 return err 8395 } 8396 sv.StartedEventId = i64 8397 } 8398 8399 case "timerId": 8400 if value != nil { 8401 jtv, ok := value.(string) 8402 if !ok { 8403 return fmt.Errorf("expected TimerId to be of type string, got %T instead", value) 8404 } 8405 sv.TimerId = ptr.String(jtv) 8406 } 8407 8408 default: 8409 _, _ = key, value 8410 8411 } 8412 } 8413 *v = sv 8414 return nil 8415} 8416 8417func awsAwsjson10_deserializeDocumentTimerStartedEventAttributes(v **types.TimerStartedEventAttributes, value interface{}) error { 8418 if v == nil { 8419 return fmt.Errorf("unexpected nil of type %T", v) 8420 } 8421 if value == nil { 8422 return nil 8423 } 8424 8425 shape, ok := value.(map[string]interface{}) 8426 if !ok { 8427 return fmt.Errorf("unexpected JSON type %v", value) 8428 } 8429 8430 var sv *types.TimerStartedEventAttributes 8431 if *v == nil { 8432 sv = &types.TimerStartedEventAttributes{} 8433 } else { 8434 sv = *v 8435 } 8436 8437 for key, value := range shape { 8438 switch key { 8439 case "control": 8440 if value != nil { 8441 jtv, ok := value.(string) 8442 if !ok { 8443 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 8444 } 8445 sv.Control = ptr.String(jtv) 8446 } 8447 8448 case "decisionTaskCompletedEventId": 8449 if value != nil { 8450 jtv, ok := value.(json.Number) 8451 if !ok { 8452 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 8453 } 8454 i64, err := jtv.Int64() 8455 if err != nil { 8456 return err 8457 } 8458 sv.DecisionTaskCompletedEventId = i64 8459 } 8460 8461 case "startToFireTimeout": 8462 if value != nil { 8463 jtv, ok := value.(string) 8464 if !ok { 8465 return fmt.Errorf("expected DurationInSeconds to be of type string, got %T instead", value) 8466 } 8467 sv.StartToFireTimeout = ptr.String(jtv) 8468 } 8469 8470 case "timerId": 8471 if value != nil { 8472 jtv, ok := value.(string) 8473 if !ok { 8474 return fmt.Errorf("expected TimerId to be of type string, got %T instead", value) 8475 } 8476 sv.TimerId = ptr.String(jtv) 8477 } 8478 8479 default: 8480 _, _ = key, value 8481 8482 } 8483 } 8484 *v = sv 8485 return nil 8486} 8487 8488func awsAwsjson10_deserializeDocumentTooManyTagsFault(v **types.TooManyTagsFault, value interface{}) error { 8489 if v == nil { 8490 return fmt.Errorf("unexpected nil of type %T", v) 8491 } 8492 if value == nil { 8493 return nil 8494 } 8495 8496 shape, ok := value.(map[string]interface{}) 8497 if !ok { 8498 return fmt.Errorf("unexpected JSON type %v", value) 8499 } 8500 8501 var sv *types.TooManyTagsFault 8502 if *v == nil { 8503 sv = &types.TooManyTagsFault{} 8504 } else { 8505 sv = *v 8506 } 8507 8508 for key, value := range shape { 8509 switch key { 8510 case "message": 8511 if value != nil { 8512 jtv, ok := value.(string) 8513 if !ok { 8514 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8515 } 8516 sv.Message = ptr.String(jtv) 8517 } 8518 8519 default: 8520 _, _ = key, value 8521 8522 } 8523 } 8524 *v = sv 8525 return nil 8526} 8527 8528func awsAwsjson10_deserializeDocumentTypeAlreadyExistsFault(v **types.TypeAlreadyExistsFault, value interface{}) error { 8529 if v == nil { 8530 return fmt.Errorf("unexpected nil of type %T", v) 8531 } 8532 if value == nil { 8533 return nil 8534 } 8535 8536 shape, ok := value.(map[string]interface{}) 8537 if !ok { 8538 return fmt.Errorf("unexpected JSON type %v", value) 8539 } 8540 8541 var sv *types.TypeAlreadyExistsFault 8542 if *v == nil { 8543 sv = &types.TypeAlreadyExistsFault{} 8544 } else { 8545 sv = *v 8546 } 8547 8548 for key, value := range shape { 8549 switch key { 8550 case "message": 8551 if value != nil { 8552 jtv, ok := value.(string) 8553 if !ok { 8554 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8555 } 8556 sv.Message = ptr.String(jtv) 8557 } 8558 8559 default: 8560 _, _ = key, value 8561 8562 } 8563 } 8564 *v = sv 8565 return nil 8566} 8567 8568func awsAwsjson10_deserializeDocumentTypeDeprecatedFault(v **types.TypeDeprecatedFault, value interface{}) error { 8569 if v == nil { 8570 return fmt.Errorf("unexpected nil of type %T", v) 8571 } 8572 if value == nil { 8573 return nil 8574 } 8575 8576 shape, ok := value.(map[string]interface{}) 8577 if !ok { 8578 return fmt.Errorf("unexpected JSON type %v", value) 8579 } 8580 8581 var sv *types.TypeDeprecatedFault 8582 if *v == nil { 8583 sv = &types.TypeDeprecatedFault{} 8584 } else { 8585 sv = *v 8586 } 8587 8588 for key, value := range shape { 8589 switch key { 8590 case "message": 8591 if value != nil { 8592 jtv, ok := value.(string) 8593 if !ok { 8594 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8595 } 8596 sv.Message = ptr.String(jtv) 8597 } 8598 8599 default: 8600 _, _ = key, value 8601 8602 } 8603 } 8604 *v = sv 8605 return nil 8606} 8607 8608func awsAwsjson10_deserializeDocumentUnknownResourceFault(v **types.UnknownResourceFault, value interface{}) error { 8609 if v == nil { 8610 return fmt.Errorf("unexpected nil of type %T", v) 8611 } 8612 if value == nil { 8613 return nil 8614 } 8615 8616 shape, ok := value.(map[string]interface{}) 8617 if !ok { 8618 return fmt.Errorf("unexpected JSON type %v", value) 8619 } 8620 8621 var sv *types.UnknownResourceFault 8622 if *v == nil { 8623 sv = &types.UnknownResourceFault{} 8624 } else { 8625 sv = *v 8626 } 8627 8628 for key, value := range shape { 8629 switch key { 8630 case "message": 8631 if value != nil { 8632 jtv, ok := value.(string) 8633 if !ok { 8634 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8635 } 8636 sv.Message = ptr.String(jtv) 8637 } 8638 8639 default: 8640 _, _ = key, value 8641 8642 } 8643 } 8644 *v = sv 8645 return nil 8646} 8647 8648func awsAwsjson10_deserializeDocumentWorkflowExecution(v **types.WorkflowExecution, value interface{}) error { 8649 if v == nil { 8650 return fmt.Errorf("unexpected nil of type %T", v) 8651 } 8652 if value == nil { 8653 return nil 8654 } 8655 8656 shape, ok := value.(map[string]interface{}) 8657 if !ok { 8658 return fmt.Errorf("unexpected JSON type %v", value) 8659 } 8660 8661 var sv *types.WorkflowExecution 8662 if *v == nil { 8663 sv = &types.WorkflowExecution{} 8664 } else { 8665 sv = *v 8666 } 8667 8668 for key, value := range shape { 8669 switch key { 8670 case "runId": 8671 if value != nil { 8672 jtv, ok := value.(string) 8673 if !ok { 8674 return fmt.Errorf("expected WorkflowRunId to be of type string, got %T instead", value) 8675 } 8676 sv.RunId = ptr.String(jtv) 8677 } 8678 8679 case "workflowId": 8680 if value != nil { 8681 jtv, ok := value.(string) 8682 if !ok { 8683 return fmt.Errorf("expected WorkflowId to be of type string, got %T instead", value) 8684 } 8685 sv.WorkflowId = ptr.String(jtv) 8686 } 8687 8688 default: 8689 _, _ = key, value 8690 8691 } 8692 } 8693 *v = sv 8694 return nil 8695} 8696 8697func awsAwsjson10_deserializeDocumentWorkflowExecutionAlreadyStartedFault(v **types.WorkflowExecutionAlreadyStartedFault, value interface{}) error { 8698 if v == nil { 8699 return fmt.Errorf("unexpected nil of type %T", v) 8700 } 8701 if value == nil { 8702 return nil 8703 } 8704 8705 shape, ok := value.(map[string]interface{}) 8706 if !ok { 8707 return fmt.Errorf("unexpected JSON type %v", value) 8708 } 8709 8710 var sv *types.WorkflowExecutionAlreadyStartedFault 8711 if *v == nil { 8712 sv = &types.WorkflowExecutionAlreadyStartedFault{} 8713 } else { 8714 sv = *v 8715 } 8716 8717 for key, value := range shape { 8718 switch key { 8719 case "message": 8720 if value != nil { 8721 jtv, ok := value.(string) 8722 if !ok { 8723 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8724 } 8725 sv.Message = ptr.String(jtv) 8726 } 8727 8728 default: 8729 _, _ = key, value 8730 8731 } 8732 } 8733 *v = sv 8734 return nil 8735} 8736 8737func awsAwsjson10_deserializeDocumentWorkflowExecutionCanceledEventAttributes(v **types.WorkflowExecutionCanceledEventAttributes, value interface{}) error { 8738 if v == nil { 8739 return fmt.Errorf("unexpected nil of type %T", v) 8740 } 8741 if value == nil { 8742 return nil 8743 } 8744 8745 shape, ok := value.(map[string]interface{}) 8746 if !ok { 8747 return fmt.Errorf("unexpected JSON type %v", value) 8748 } 8749 8750 var sv *types.WorkflowExecutionCanceledEventAttributes 8751 if *v == nil { 8752 sv = &types.WorkflowExecutionCanceledEventAttributes{} 8753 } else { 8754 sv = *v 8755 } 8756 8757 for key, value := range shape { 8758 switch key { 8759 case "decisionTaskCompletedEventId": 8760 if value != nil { 8761 jtv, ok := value.(json.Number) 8762 if !ok { 8763 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 8764 } 8765 i64, err := jtv.Int64() 8766 if err != nil { 8767 return err 8768 } 8769 sv.DecisionTaskCompletedEventId = i64 8770 } 8771 8772 case "details": 8773 if value != nil { 8774 jtv, ok := value.(string) 8775 if !ok { 8776 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 8777 } 8778 sv.Details = ptr.String(jtv) 8779 } 8780 8781 default: 8782 _, _ = key, value 8783 8784 } 8785 } 8786 *v = sv 8787 return nil 8788} 8789 8790func awsAwsjson10_deserializeDocumentWorkflowExecutionCancelRequestedEventAttributes(v **types.WorkflowExecutionCancelRequestedEventAttributes, value interface{}) error { 8791 if v == nil { 8792 return fmt.Errorf("unexpected nil of type %T", v) 8793 } 8794 if value == nil { 8795 return nil 8796 } 8797 8798 shape, ok := value.(map[string]interface{}) 8799 if !ok { 8800 return fmt.Errorf("unexpected JSON type %v", value) 8801 } 8802 8803 var sv *types.WorkflowExecutionCancelRequestedEventAttributes 8804 if *v == nil { 8805 sv = &types.WorkflowExecutionCancelRequestedEventAttributes{} 8806 } else { 8807 sv = *v 8808 } 8809 8810 for key, value := range shape { 8811 switch key { 8812 case "cause": 8813 if value != nil { 8814 jtv, ok := value.(string) 8815 if !ok { 8816 return fmt.Errorf("expected WorkflowExecutionCancelRequestedCause to be of type string, got %T instead", value) 8817 } 8818 sv.Cause = types.WorkflowExecutionCancelRequestedCause(jtv) 8819 } 8820 8821 case "externalInitiatedEventId": 8822 if value != nil { 8823 jtv, ok := value.(json.Number) 8824 if !ok { 8825 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 8826 } 8827 i64, err := jtv.Int64() 8828 if err != nil { 8829 return err 8830 } 8831 sv.ExternalInitiatedEventId = i64 8832 } 8833 8834 case "externalWorkflowExecution": 8835 if err := awsAwsjson10_deserializeDocumentWorkflowExecution(&sv.ExternalWorkflowExecution, value); err != nil { 8836 return err 8837 } 8838 8839 default: 8840 _, _ = key, value 8841 8842 } 8843 } 8844 *v = sv 8845 return nil 8846} 8847 8848func awsAwsjson10_deserializeDocumentWorkflowExecutionCompletedEventAttributes(v **types.WorkflowExecutionCompletedEventAttributes, value interface{}) error { 8849 if v == nil { 8850 return fmt.Errorf("unexpected nil of type %T", v) 8851 } 8852 if value == nil { 8853 return nil 8854 } 8855 8856 shape, ok := value.(map[string]interface{}) 8857 if !ok { 8858 return fmt.Errorf("unexpected JSON type %v", value) 8859 } 8860 8861 var sv *types.WorkflowExecutionCompletedEventAttributes 8862 if *v == nil { 8863 sv = &types.WorkflowExecutionCompletedEventAttributes{} 8864 } else { 8865 sv = *v 8866 } 8867 8868 for key, value := range shape { 8869 switch key { 8870 case "decisionTaskCompletedEventId": 8871 if value != nil { 8872 jtv, ok := value.(json.Number) 8873 if !ok { 8874 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 8875 } 8876 i64, err := jtv.Int64() 8877 if err != nil { 8878 return err 8879 } 8880 sv.DecisionTaskCompletedEventId = i64 8881 } 8882 8883 case "result": 8884 if value != nil { 8885 jtv, ok := value.(string) 8886 if !ok { 8887 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 8888 } 8889 sv.Result = ptr.String(jtv) 8890 } 8891 8892 default: 8893 _, _ = key, value 8894 8895 } 8896 } 8897 *v = sv 8898 return nil 8899} 8900 8901func awsAwsjson10_deserializeDocumentWorkflowExecutionConfiguration(v **types.WorkflowExecutionConfiguration, value interface{}) error { 8902 if v == nil { 8903 return fmt.Errorf("unexpected nil of type %T", v) 8904 } 8905 if value == nil { 8906 return nil 8907 } 8908 8909 shape, ok := value.(map[string]interface{}) 8910 if !ok { 8911 return fmt.Errorf("unexpected JSON type %v", value) 8912 } 8913 8914 var sv *types.WorkflowExecutionConfiguration 8915 if *v == nil { 8916 sv = &types.WorkflowExecutionConfiguration{} 8917 } else { 8918 sv = *v 8919 } 8920 8921 for key, value := range shape { 8922 switch key { 8923 case "childPolicy": 8924 if value != nil { 8925 jtv, ok := value.(string) 8926 if !ok { 8927 return fmt.Errorf("expected ChildPolicy to be of type string, got %T instead", value) 8928 } 8929 sv.ChildPolicy = types.ChildPolicy(jtv) 8930 } 8931 8932 case "executionStartToCloseTimeout": 8933 if value != nil { 8934 jtv, ok := value.(string) 8935 if !ok { 8936 return fmt.Errorf("expected DurationInSeconds to be of type string, got %T instead", value) 8937 } 8938 sv.ExecutionStartToCloseTimeout = ptr.String(jtv) 8939 } 8940 8941 case "lambdaRole": 8942 if value != nil { 8943 jtv, ok := value.(string) 8944 if !ok { 8945 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 8946 } 8947 sv.LambdaRole = ptr.String(jtv) 8948 } 8949 8950 case "taskList": 8951 if err := awsAwsjson10_deserializeDocumentTaskList(&sv.TaskList, value); err != nil { 8952 return err 8953 } 8954 8955 case "taskPriority": 8956 if value != nil { 8957 jtv, ok := value.(string) 8958 if !ok { 8959 return fmt.Errorf("expected TaskPriority to be of type string, got %T instead", value) 8960 } 8961 sv.TaskPriority = ptr.String(jtv) 8962 } 8963 8964 case "taskStartToCloseTimeout": 8965 if value != nil { 8966 jtv, ok := value.(string) 8967 if !ok { 8968 return fmt.Errorf("expected DurationInSeconds to be of type string, got %T instead", value) 8969 } 8970 sv.TaskStartToCloseTimeout = ptr.String(jtv) 8971 } 8972 8973 default: 8974 _, _ = key, value 8975 8976 } 8977 } 8978 *v = sv 8979 return nil 8980} 8981 8982func awsAwsjson10_deserializeDocumentWorkflowExecutionContinuedAsNewEventAttributes(v **types.WorkflowExecutionContinuedAsNewEventAttributes, value interface{}) error { 8983 if v == nil { 8984 return fmt.Errorf("unexpected nil of type %T", v) 8985 } 8986 if value == nil { 8987 return nil 8988 } 8989 8990 shape, ok := value.(map[string]interface{}) 8991 if !ok { 8992 return fmt.Errorf("unexpected JSON type %v", value) 8993 } 8994 8995 var sv *types.WorkflowExecutionContinuedAsNewEventAttributes 8996 if *v == nil { 8997 sv = &types.WorkflowExecutionContinuedAsNewEventAttributes{} 8998 } else { 8999 sv = *v 9000 } 9001 9002 for key, value := range shape { 9003 switch key { 9004 case "childPolicy": 9005 if value != nil { 9006 jtv, ok := value.(string) 9007 if !ok { 9008 return fmt.Errorf("expected ChildPolicy to be of type string, got %T instead", value) 9009 } 9010 sv.ChildPolicy = types.ChildPolicy(jtv) 9011 } 9012 9013 case "decisionTaskCompletedEventId": 9014 if value != nil { 9015 jtv, ok := value.(json.Number) 9016 if !ok { 9017 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 9018 } 9019 i64, err := jtv.Int64() 9020 if err != nil { 9021 return err 9022 } 9023 sv.DecisionTaskCompletedEventId = i64 9024 } 9025 9026 case "executionStartToCloseTimeout": 9027 if value != nil { 9028 jtv, ok := value.(string) 9029 if !ok { 9030 return fmt.Errorf("expected DurationInSecondsOptional to be of type string, got %T instead", value) 9031 } 9032 sv.ExecutionStartToCloseTimeout = ptr.String(jtv) 9033 } 9034 9035 case "input": 9036 if value != nil { 9037 jtv, ok := value.(string) 9038 if !ok { 9039 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 9040 } 9041 sv.Input = ptr.String(jtv) 9042 } 9043 9044 case "lambdaRole": 9045 if value != nil { 9046 jtv, ok := value.(string) 9047 if !ok { 9048 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 9049 } 9050 sv.LambdaRole = ptr.String(jtv) 9051 } 9052 9053 case "newExecutionRunId": 9054 if value != nil { 9055 jtv, ok := value.(string) 9056 if !ok { 9057 return fmt.Errorf("expected WorkflowRunId to be of type string, got %T instead", value) 9058 } 9059 sv.NewExecutionRunId = ptr.String(jtv) 9060 } 9061 9062 case "tagList": 9063 if err := awsAwsjson10_deserializeDocumentTagList(&sv.TagList, value); err != nil { 9064 return err 9065 } 9066 9067 case "taskList": 9068 if err := awsAwsjson10_deserializeDocumentTaskList(&sv.TaskList, value); err != nil { 9069 return err 9070 } 9071 9072 case "taskPriority": 9073 if value != nil { 9074 jtv, ok := value.(string) 9075 if !ok { 9076 return fmt.Errorf("expected TaskPriority to be of type string, got %T instead", value) 9077 } 9078 sv.TaskPriority = ptr.String(jtv) 9079 } 9080 9081 case "taskStartToCloseTimeout": 9082 if value != nil { 9083 jtv, ok := value.(string) 9084 if !ok { 9085 return fmt.Errorf("expected DurationInSecondsOptional to be of type string, got %T instead", value) 9086 } 9087 sv.TaskStartToCloseTimeout = ptr.String(jtv) 9088 } 9089 9090 case "workflowType": 9091 if err := awsAwsjson10_deserializeDocumentWorkflowType(&sv.WorkflowType, value); err != nil { 9092 return err 9093 } 9094 9095 default: 9096 _, _ = key, value 9097 9098 } 9099 } 9100 *v = sv 9101 return nil 9102} 9103 9104func awsAwsjson10_deserializeDocumentWorkflowExecutionFailedEventAttributes(v **types.WorkflowExecutionFailedEventAttributes, value interface{}) error { 9105 if v == nil { 9106 return fmt.Errorf("unexpected nil of type %T", v) 9107 } 9108 if value == nil { 9109 return nil 9110 } 9111 9112 shape, ok := value.(map[string]interface{}) 9113 if !ok { 9114 return fmt.Errorf("unexpected JSON type %v", value) 9115 } 9116 9117 var sv *types.WorkflowExecutionFailedEventAttributes 9118 if *v == nil { 9119 sv = &types.WorkflowExecutionFailedEventAttributes{} 9120 } else { 9121 sv = *v 9122 } 9123 9124 for key, value := range shape { 9125 switch key { 9126 case "decisionTaskCompletedEventId": 9127 if value != nil { 9128 jtv, ok := value.(json.Number) 9129 if !ok { 9130 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 9131 } 9132 i64, err := jtv.Int64() 9133 if err != nil { 9134 return err 9135 } 9136 sv.DecisionTaskCompletedEventId = i64 9137 } 9138 9139 case "details": 9140 if value != nil { 9141 jtv, ok := value.(string) 9142 if !ok { 9143 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 9144 } 9145 sv.Details = ptr.String(jtv) 9146 } 9147 9148 case "reason": 9149 if value != nil { 9150 jtv, ok := value.(string) 9151 if !ok { 9152 return fmt.Errorf("expected FailureReason to be of type string, got %T instead", value) 9153 } 9154 sv.Reason = ptr.String(jtv) 9155 } 9156 9157 default: 9158 _, _ = key, value 9159 9160 } 9161 } 9162 *v = sv 9163 return nil 9164} 9165 9166func awsAwsjson10_deserializeDocumentWorkflowExecutionInfo(v **types.WorkflowExecutionInfo, value interface{}) error { 9167 if v == nil { 9168 return fmt.Errorf("unexpected nil of type %T", v) 9169 } 9170 if value == nil { 9171 return nil 9172 } 9173 9174 shape, ok := value.(map[string]interface{}) 9175 if !ok { 9176 return fmt.Errorf("unexpected JSON type %v", value) 9177 } 9178 9179 var sv *types.WorkflowExecutionInfo 9180 if *v == nil { 9181 sv = &types.WorkflowExecutionInfo{} 9182 } else { 9183 sv = *v 9184 } 9185 9186 for key, value := range shape { 9187 switch key { 9188 case "cancelRequested": 9189 if value != nil { 9190 jtv, ok := value.(bool) 9191 if !ok { 9192 return fmt.Errorf("expected Canceled to be of type *bool, got %T instead", value) 9193 } 9194 sv.CancelRequested = jtv 9195 } 9196 9197 case "closeStatus": 9198 if value != nil { 9199 jtv, ok := value.(string) 9200 if !ok { 9201 return fmt.Errorf("expected CloseStatus to be of type string, got %T instead", value) 9202 } 9203 sv.CloseStatus = types.CloseStatus(jtv) 9204 } 9205 9206 case "closeTimestamp": 9207 if value != nil { 9208 jtv, ok := value.(json.Number) 9209 if !ok { 9210 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9211 } 9212 f64, err := jtv.Float64() 9213 if err != nil { 9214 return err 9215 } 9216 sv.CloseTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9217 } 9218 9219 case "execution": 9220 if err := awsAwsjson10_deserializeDocumentWorkflowExecution(&sv.Execution, value); err != nil { 9221 return err 9222 } 9223 9224 case "executionStatus": 9225 if value != nil { 9226 jtv, ok := value.(string) 9227 if !ok { 9228 return fmt.Errorf("expected ExecutionStatus to be of type string, got %T instead", value) 9229 } 9230 sv.ExecutionStatus = types.ExecutionStatus(jtv) 9231 } 9232 9233 case "parent": 9234 if err := awsAwsjson10_deserializeDocumentWorkflowExecution(&sv.Parent, value); err != nil { 9235 return err 9236 } 9237 9238 case "startTimestamp": 9239 if value != nil { 9240 jtv, ok := value.(json.Number) 9241 if !ok { 9242 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9243 } 9244 f64, err := jtv.Float64() 9245 if err != nil { 9246 return err 9247 } 9248 sv.StartTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9249 } 9250 9251 case "tagList": 9252 if err := awsAwsjson10_deserializeDocumentTagList(&sv.TagList, value); err != nil { 9253 return err 9254 } 9255 9256 case "workflowType": 9257 if err := awsAwsjson10_deserializeDocumentWorkflowType(&sv.WorkflowType, value); err != nil { 9258 return err 9259 } 9260 9261 default: 9262 _, _ = key, value 9263 9264 } 9265 } 9266 *v = sv 9267 return nil 9268} 9269 9270func awsAwsjson10_deserializeDocumentWorkflowExecutionInfoList(v *[]types.WorkflowExecutionInfo, value interface{}) error { 9271 if v == nil { 9272 return fmt.Errorf("unexpected nil of type %T", v) 9273 } 9274 if value == nil { 9275 return nil 9276 } 9277 9278 shape, ok := value.([]interface{}) 9279 if !ok { 9280 return fmt.Errorf("unexpected JSON type %v", value) 9281 } 9282 9283 var cv []types.WorkflowExecutionInfo 9284 if *v == nil { 9285 cv = []types.WorkflowExecutionInfo{} 9286 } else { 9287 cv = *v 9288 } 9289 9290 for _, value := range shape { 9291 var col types.WorkflowExecutionInfo 9292 destAddr := &col 9293 if err := awsAwsjson10_deserializeDocumentWorkflowExecutionInfo(&destAddr, value); err != nil { 9294 return err 9295 } 9296 col = *destAddr 9297 cv = append(cv, col) 9298 9299 } 9300 *v = cv 9301 return nil 9302} 9303 9304func awsAwsjson10_deserializeDocumentWorkflowExecutionOpenCounts(v **types.WorkflowExecutionOpenCounts, value interface{}) error { 9305 if v == nil { 9306 return fmt.Errorf("unexpected nil of type %T", v) 9307 } 9308 if value == nil { 9309 return nil 9310 } 9311 9312 shape, ok := value.(map[string]interface{}) 9313 if !ok { 9314 return fmt.Errorf("unexpected JSON type %v", value) 9315 } 9316 9317 var sv *types.WorkflowExecutionOpenCounts 9318 if *v == nil { 9319 sv = &types.WorkflowExecutionOpenCounts{} 9320 } else { 9321 sv = *v 9322 } 9323 9324 for key, value := range shape { 9325 switch key { 9326 case "openActivityTasks": 9327 if value != nil { 9328 jtv, ok := value.(json.Number) 9329 if !ok { 9330 return fmt.Errorf("expected Count to be json.Number, got %T instead", value) 9331 } 9332 i64, err := jtv.Int64() 9333 if err != nil { 9334 return err 9335 } 9336 sv.OpenActivityTasks = int32(i64) 9337 } 9338 9339 case "openChildWorkflowExecutions": 9340 if value != nil { 9341 jtv, ok := value.(json.Number) 9342 if !ok { 9343 return fmt.Errorf("expected Count to be json.Number, got %T instead", value) 9344 } 9345 i64, err := jtv.Int64() 9346 if err != nil { 9347 return err 9348 } 9349 sv.OpenChildWorkflowExecutions = int32(i64) 9350 } 9351 9352 case "openDecisionTasks": 9353 if value != nil { 9354 jtv, ok := value.(json.Number) 9355 if !ok { 9356 return fmt.Errorf("expected OpenDecisionTasksCount to be json.Number, got %T instead", value) 9357 } 9358 i64, err := jtv.Int64() 9359 if err != nil { 9360 return err 9361 } 9362 sv.OpenDecisionTasks = int32(i64) 9363 } 9364 9365 case "openLambdaFunctions": 9366 if value != nil { 9367 jtv, ok := value.(json.Number) 9368 if !ok { 9369 return fmt.Errorf("expected Count to be json.Number, got %T instead", value) 9370 } 9371 i64, err := jtv.Int64() 9372 if err != nil { 9373 return err 9374 } 9375 sv.OpenLambdaFunctions = int32(i64) 9376 } 9377 9378 case "openTimers": 9379 if value != nil { 9380 jtv, ok := value.(json.Number) 9381 if !ok { 9382 return fmt.Errorf("expected Count to be json.Number, got %T instead", value) 9383 } 9384 i64, err := jtv.Int64() 9385 if err != nil { 9386 return err 9387 } 9388 sv.OpenTimers = int32(i64) 9389 } 9390 9391 default: 9392 _, _ = key, value 9393 9394 } 9395 } 9396 *v = sv 9397 return nil 9398} 9399 9400func awsAwsjson10_deserializeDocumentWorkflowExecutionSignaledEventAttributes(v **types.WorkflowExecutionSignaledEventAttributes, value interface{}) error { 9401 if v == nil { 9402 return fmt.Errorf("unexpected nil of type %T", v) 9403 } 9404 if value == nil { 9405 return nil 9406 } 9407 9408 shape, ok := value.(map[string]interface{}) 9409 if !ok { 9410 return fmt.Errorf("unexpected JSON type %v", value) 9411 } 9412 9413 var sv *types.WorkflowExecutionSignaledEventAttributes 9414 if *v == nil { 9415 sv = &types.WorkflowExecutionSignaledEventAttributes{} 9416 } else { 9417 sv = *v 9418 } 9419 9420 for key, value := range shape { 9421 switch key { 9422 case "externalInitiatedEventId": 9423 if value != nil { 9424 jtv, ok := value.(json.Number) 9425 if !ok { 9426 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 9427 } 9428 i64, err := jtv.Int64() 9429 if err != nil { 9430 return err 9431 } 9432 sv.ExternalInitiatedEventId = i64 9433 } 9434 9435 case "externalWorkflowExecution": 9436 if err := awsAwsjson10_deserializeDocumentWorkflowExecution(&sv.ExternalWorkflowExecution, value); err != nil { 9437 return err 9438 } 9439 9440 case "input": 9441 if value != nil { 9442 jtv, ok := value.(string) 9443 if !ok { 9444 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 9445 } 9446 sv.Input = ptr.String(jtv) 9447 } 9448 9449 case "signalName": 9450 if value != nil { 9451 jtv, ok := value.(string) 9452 if !ok { 9453 return fmt.Errorf("expected SignalName to be of type string, got %T instead", value) 9454 } 9455 sv.SignalName = ptr.String(jtv) 9456 } 9457 9458 default: 9459 _, _ = key, value 9460 9461 } 9462 } 9463 *v = sv 9464 return nil 9465} 9466 9467func awsAwsjson10_deserializeDocumentWorkflowExecutionStartedEventAttributes(v **types.WorkflowExecutionStartedEventAttributes, value interface{}) error { 9468 if v == nil { 9469 return fmt.Errorf("unexpected nil of type %T", v) 9470 } 9471 if value == nil { 9472 return nil 9473 } 9474 9475 shape, ok := value.(map[string]interface{}) 9476 if !ok { 9477 return fmt.Errorf("unexpected JSON type %v", value) 9478 } 9479 9480 var sv *types.WorkflowExecutionStartedEventAttributes 9481 if *v == nil { 9482 sv = &types.WorkflowExecutionStartedEventAttributes{} 9483 } else { 9484 sv = *v 9485 } 9486 9487 for key, value := range shape { 9488 switch key { 9489 case "childPolicy": 9490 if value != nil { 9491 jtv, ok := value.(string) 9492 if !ok { 9493 return fmt.Errorf("expected ChildPolicy to be of type string, got %T instead", value) 9494 } 9495 sv.ChildPolicy = types.ChildPolicy(jtv) 9496 } 9497 9498 case "continuedExecutionRunId": 9499 if value != nil { 9500 jtv, ok := value.(string) 9501 if !ok { 9502 return fmt.Errorf("expected WorkflowRunIdOptional to be of type string, got %T instead", value) 9503 } 9504 sv.ContinuedExecutionRunId = ptr.String(jtv) 9505 } 9506 9507 case "executionStartToCloseTimeout": 9508 if value != nil { 9509 jtv, ok := value.(string) 9510 if !ok { 9511 return fmt.Errorf("expected DurationInSecondsOptional to be of type string, got %T instead", value) 9512 } 9513 sv.ExecutionStartToCloseTimeout = ptr.String(jtv) 9514 } 9515 9516 case "input": 9517 if value != nil { 9518 jtv, ok := value.(string) 9519 if !ok { 9520 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 9521 } 9522 sv.Input = ptr.String(jtv) 9523 } 9524 9525 case "lambdaRole": 9526 if value != nil { 9527 jtv, ok := value.(string) 9528 if !ok { 9529 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 9530 } 9531 sv.LambdaRole = ptr.String(jtv) 9532 } 9533 9534 case "parentInitiatedEventId": 9535 if value != nil { 9536 jtv, ok := value.(json.Number) 9537 if !ok { 9538 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 9539 } 9540 i64, err := jtv.Int64() 9541 if err != nil { 9542 return err 9543 } 9544 sv.ParentInitiatedEventId = i64 9545 } 9546 9547 case "parentWorkflowExecution": 9548 if err := awsAwsjson10_deserializeDocumentWorkflowExecution(&sv.ParentWorkflowExecution, value); err != nil { 9549 return err 9550 } 9551 9552 case "tagList": 9553 if err := awsAwsjson10_deserializeDocumentTagList(&sv.TagList, value); err != nil { 9554 return err 9555 } 9556 9557 case "taskList": 9558 if err := awsAwsjson10_deserializeDocumentTaskList(&sv.TaskList, value); err != nil { 9559 return err 9560 } 9561 9562 case "taskPriority": 9563 if value != nil { 9564 jtv, ok := value.(string) 9565 if !ok { 9566 return fmt.Errorf("expected TaskPriority to be of type string, got %T instead", value) 9567 } 9568 sv.TaskPriority = ptr.String(jtv) 9569 } 9570 9571 case "taskStartToCloseTimeout": 9572 if value != nil { 9573 jtv, ok := value.(string) 9574 if !ok { 9575 return fmt.Errorf("expected DurationInSecondsOptional to be of type string, got %T instead", value) 9576 } 9577 sv.TaskStartToCloseTimeout = ptr.String(jtv) 9578 } 9579 9580 case "workflowType": 9581 if err := awsAwsjson10_deserializeDocumentWorkflowType(&sv.WorkflowType, value); err != nil { 9582 return err 9583 } 9584 9585 default: 9586 _, _ = key, value 9587 9588 } 9589 } 9590 *v = sv 9591 return nil 9592} 9593 9594func awsAwsjson10_deserializeDocumentWorkflowExecutionTerminatedEventAttributes(v **types.WorkflowExecutionTerminatedEventAttributes, value interface{}) error { 9595 if v == nil { 9596 return fmt.Errorf("unexpected nil of type %T", v) 9597 } 9598 if value == nil { 9599 return nil 9600 } 9601 9602 shape, ok := value.(map[string]interface{}) 9603 if !ok { 9604 return fmt.Errorf("unexpected JSON type %v", value) 9605 } 9606 9607 var sv *types.WorkflowExecutionTerminatedEventAttributes 9608 if *v == nil { 9609 sv = &types.WorkflowExecutionTerminatedEventAttributes{} 9610 } else { 9611 sv = *v 9612 } 9613 9614 for key, value := range shape { 9615 switch key { 9616 case "cause": 9617 if value != nil { 9618 jtv, ok := value.(string) 9619 if !ok { 9620 return fmt.Errorf("expected WorkflowExecutionTerminatedCause to be of type string, got %T instead", value) 9621 } 9622 sv.Cause = types.WorkflowExecutionTerminatedCause(jtv) 9623 } 9624 9625 case "childPolicy": 9626 if value != nil { 9627 jtv, ok := value.(string) 9628 if !ok { 9629 return fmt.Errorf("expected ChildPolicy to be of type string, got %T instead", value) 9630 } 9631 sv.ChildPolicy = types.ChildPolicy(jtv) 9632 } 9633 9634 case "details": 9635 if value != nil { 9636 jtv, ok := value.(string) 9637 if !ok { 9638 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 9639 } 9640 sv.Details = ptr.String(jtv) 9641 } 9642 9643 case "reason": 9644 if value != nil { 9645 jtv, ok := value.(string) 9646 if !ok { 9647 return fmt.Errorf("expected TerminateReason to be of type string, got %T instead", value) 9648 } 9649 sv.Reason = ptr.String(jtv) 9650 } 9651 9652 default: 9653 _, _ = key, value 9654 9655 } 9656 } 9657 *v = sv 9658 return nil 9659} 9660 9661func awsAwsjson10_deserializeDocumentWorkflowExecutionTimedOutEventAttributes(v **types.WorkflowExecutionTimedOutEventAttributes, value interface{}) error { 9662 if v == nil { 9663 return fmt.Errorf("unexpected nil of type %T", v) 9664 } 9665 if value == nil { 9666 return nil 9667 } 9668 9669 shape, ok := value.(map[string]interface{}) 9670 if !ok { 9671 return fmt.Errorf("unexpected JSON type %v", value) 9672 } 9673 9674 var sv *types.WorkflowExecutionTimedOutEventAttributes 9675 if *v == nil { 9676 sv = &types.WorkflowExecutionTimedOutEventAttributes{} 9677 } else { 9678 sv = *v 9679 } 9680 9681 for key, value := range shape { 9682 switch key { 9683 case "childPolicy": 9684 if value != nil { 9685 jtv, ok := value.(string) 9686 if !ok { 9687 return fmt.Errorf("expected ChildPolicy to be of type string, got %T instead", value) 9688 } 9689 sv.ChildPolicy = types.ChildPolicy(jtv) 9690 } 9691 9692 case "timeoutType": 9693 if value != nil { 9694 jtv, ok := value.(string) 9695 if !ok { 9696 return fmt.Errorf("expected WorkflowExecutionTimeoutType to be of type string, got %T instead", value) 9697 } 9698 sv.TimeoutType = types.WorkflowExecutionTimeoutType(jtv) 9699 } 9700 9701 default: 9702 _, _ = key, value 9703 9704 } 9705 } 9706 *v = sv 9707 return nil 9708} 9709 9710func awsAwsjson10_deserializeDocumentWorkflowType(v **types.WorkflowType, value interface{}) error { 9711 if v == nil { 9712 return fmt.Errorf("unexpected nil of type %T", v) 9713 } 9714 if value == nil { 9715 return nil 9716 } 9717 9718 shape, ok := value.(map[string]interface{}) 9719 if !ok { 9720 return fmt.Errorf("unexpected JSON type %v", value) 9721 } 9722 9723 var sv *types.WorkflowType 9724 if *v == nil { 9725 sv = &types.WorkflowType{} 9726 } else { 9727 sv = *v 9728 } 9729 9730 for key, value := range shape { 9731 switch key { 9732 case "name": 9733 if value != nil { 9734 jtv, ok := value.(string) 9735 if !ok { 9736 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 9737 } 9738 sv.Name = ptr.String(jtv) 9739 } 9740 9741 case "version": 9742 if value != nil { 9743 jtv, ok := value.(string) 9744 if !ok { 9745 return fmt.Errorf("expected Version to be of type string, got %T instead", value) 9746 } 9747 sv.Version = ptr.String(jtv) 9748 } 9749 9750 default: 9751 _, _ = key, value 9752 9753 } 9754 } 9755 *v = sv 9756 return nil 9757} 9758 9759func awsAwsjson10_deserializeDocumentWorkflowTypeConfiguration(v **types.WorkflowTypeConfiguration, value interface{}) error { 9760 if v == nil { 9761 return fmt.Errorf("unexpected nil of type %T", v) 9762 } 9763 if value == nil { 9764 return nil 9765 } 9766 9767 shape, ok := value.(map[string]interface{}) 9768 if !ok { 9769 return fmt.Errorf("unexpected JSON type %v", value) 9770 } 9771 9772 var sv *types.WorkflowTypeConfiguration 9773 if *v == nil { 9774 sv = &types.WorkflowTypeConfiguration{} 9775 } else { 9776 sv = *v 9777 } 9778 9779 for key, value := range shape { 9780 switch key { 9781 case "defaultChildPolicy": 9782 if value != nil { 9783 jtv, ok := value.(string) 9784 if !ok { 9785 return fmt.Errorf("expected ChildPolicy to be of type string, got %T instead", value) 9786 } 9787 sv.DefaultChildPolicy = types.ChildPolicy(jtv) 9788 } 9789 9790 case "defaultExecutionStartToCloseTimeout": 9791 if value != nil { 9792 jtv, ok := value.(string) 9793 if !ok { 9794 return fmt.Errorf("expected DurationInSecondsOptional to be of type string, got %T instead", value) 9795 } 9796 sv.DefaultExecutionStartToCloseTimeout = ptr.String(jtv) 9797 } 9798 9799 case "defaultLambdaRole": 9800 if value != nil { 9801 jtv, ok := value.(string) 9802 if !ok { 9803 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 9804 } 9805 sv.DefaultLambdaRole = ptr.String(jtv) 9806 } 9807 9808 case "defaultTaskList": 9809 if err := awsAwsjson10_deserializeDocumentTaskList(&sv.DefaultTaskList, value); err != nil { 9810 return err 9811 } 9812 9813 case "defaultTaskPriority": 9814 if value != nil { 9815 jtv, ok := value.(string) 9816 if !ok { 9817 return fmt.Errorf("expected TaskPriority to be of type string, got %T instead", value) 9818 } 9819 sv.DefaultTaskPriority = ptr.String(jtv) 9820 } 9821 9822 case "defaultTaskStartToCloseTimeout": 9823 if value != nil { 9824 jtv, ok := value.(string) 9825 if !ok { 9826 return fmt.Errorf("expected DurationInSecondsOptional to be of type string, got %T instead", value) 9827 } 9828 sv.DefaultTaskStartToCloseTimeout = ptr.String(jtv) 9829 } 9830 9831 default: 9832 _, _ = key, value 9833 9834 } 9835 } 9836 *v = sv 9837 return nil 9838} 9839 9840func awsAwsjson10_deserializeDocumentWorkflowTypeInfo(v **types.WorkflowTypeInfo, value interface{}) error { 9841 if v == nil { 9842 return fmt.Errorf("unexpected nil of type %T", v) 9843 } 9844 if value == nil { 9845 return nil 9846 } 9847 9848 shape, ok := value.(map[string]interface{}) 9849 if !ok { 9850 return fmt.Errorf("unexpected JSON type %v", value) 9851 } 9852 9853 var sv *types.WorkflowTypeInfo 9854 if *v == nil { 9855 sv = &types.WorkflowTypeInfo{} 9856 } else { 9857 sv = *v 9858 } 9859 9860 for key, value := range shape { 9861 switch key { 9862 case "creationDate": 9863 if value != nil { 9864 jtv, ok := value.(json.Number) 9865 if !ok { 9866 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9867 } 9868 f64, err := jtv.Float64() 9869 if err != nil { 9870 return err 9871 } 9872 sv.CreationDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9873 } 9874 9875 case "deprecationDate": 9876 if value != nil { 9877 jtv, ok := value.(json.Number) 9878 if !ok { 9879 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9880 } 9881 f64, err := jtv.Float64() 9882 if err != nil { 9883 return err 9884 } 9885 sv.DeprecationDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9886 } 9887 9888 case "description": 9889 if value != nil { 9890 jtv, ok := value.(string) 9891 if !ok { 9892 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 9893 } 9894 sv.Description = ptr.String(jtv) 9895 } 9896 9897 case "status": 9898 if value != nil { 9899 jtv, ok := value.(string) 9900 if !ok { 9901 return fmt.Errorf("expected RegistrationStatus to be of type string, got %T instead", value) 9902 } 9903 sv.Status = types.RegistrationStatus(jtv) 9904 } 9905 9906 case "workflowType": 9907 if err := awsAwsjson10_deserializeDocumentWorkflowType(&sv.WorkflowType, value); err != nil { 9908 return err 9909 } 9910 9911 default: 9912 _, _ = key, value 9913 9914 } 9915 } 9916 *v = sv 9917 return nil 9918} 9919 9920func awsAwsjson10_deserializeDocumentWorkflowTypeInfoList(v *[]types.WorkflowTypeInfo, value interface{}) error { 9921 if v == nil { 9922 return fmt.Errorf("unexpected nil of type %T", v) 9923 } 9924 if value == nil { 9925 return nil 9926 } 9927 9928 shape, ok := value.([]interface{}) 9929 if !ok { 9930 return fmt.Errorf("unexpected JSON type %v", value) 9931 } 9932 9933 var cv []types.WorkflowTypeInfo 9934 if *v == nil { 9935 cv = []types.WorkflowTypeInfo{} 9936 } else { 9937 cv = *v 9938 } 9939 9940 for _, value := range shape { 9941 var col types.WorkflowTypeInfo 9942 destAddr := &col 9943 if err := awsAwsjson10_deserializeDocumentWorkflowTypeInfo(&destAddr, value); err != nil { 9944 return err 9945 } 9946 col = *destAddr 9947 cv = append(cv, col) 9948 9949 } 9950 *v = cv 9951 return nil 9952} 9953 9954func awsAwsjson10_deserializeOpDocumentCountClosedWorkflowExecutionsOutput(v **CountClosedWorkflowExecutionsOutput, value interface{}) error { 9955 if v == nil { 9956 return fmt.Errorf("unexpected nil of type %T", v) 9957 } 9958 if value == nil { 9959 return nil 9960 } 9961 9962 shape, ok := value.(map[string]interface{}) 9963 if !ok { 9964 return fmt.Errorf("unexpected JSON type %v", value) 9965 } 9966 9967 var sv *CountClosedWorkflowExecutionsOutput 9968 if *v == nil { 9969 sv = &CountClosedWorkflowExecutionsOutput{} 9970 } else { 9971 sv = *v 9972 } 9973 9974 for key, value := range shape { 9975 switch key { 9976 case "count": 9977 if value != nil { 9978 jtv, ok := value.(json.Number) 9979 if !ok { 9980 return fmt.Errorf("expected Count to be json.Number, got %T instead", value) 9981 } 9982 i64, err := jtv.Int64() 9983 if err != nil { 9984 return err 9985 } 9986 sv.Count = int32(i64) 9987 } 9988 9989 case "truncated": 9990 if value != nil { 9991 jtv, ok := value.(bool) 9992 if !ok { 9993 return fmt.Errorf("expected Truncated to be of type *bool, got %T instead", value) 9994 } 9995 sv.Truncated = jtv 9996 } 9997 9998 default: 9999 _, _ = key, value 10000 10001 } 10002 } 10003 *v = sv 10004 return nil 10005} 10006 10007func awsAwsjson10_deserializeOpDocumentCountOpenWorkflowExecutionsOutput(v **CountOpenWorkflowExecutionsOutput, value interface{}) error { 10008 if v == nil { 10009 return fmt.Errorf("unexpected nil of type %T", v) 10010 } 10011 if value == nil { 10012 return nil 10013 } 10014 10015 shape, ok := value.(map[string]interface{}) 10016 if !ok { 10017 return fmt.Errorf("unexpected JSON type %v", value) 10018 } 10019 10020 var sv *CountOpenWorkflowExecutionsOutput 10021 if *v == nil { 10022 sv = &CountOpenWorkflowExecutionsOutput{} 10023 } else { 10024 sv = *v 10025 } 10026 10027 for key, value := range shape { 10028 switch key { 10029 case "count": 10030 if value != nil { 10031 jtv, ok := value.(json.Number) 10032 if !ok { 10033 return fmt.Errorf("expected Count to be json.Number, got %T instead", value) 10034 } 10035 i64, err := jtv.Int64() 10036 if err != nil { 10037 return err 10038 } 10039 sv.Count = int32(i64) 10040 } 10041 10042 case "truncated": 10043 if value != nil { 10044 jtv, ok := value.(bool) 10045 if !ok { 10046 return fmt.Errorf("expected Truncated to be of type *bool, got %T instead", value) 10047 } 10048 sv.Truncated = jtv 10049 } 10050 10051 default: 10052 _, _ = key, value 10053 10054 } 10055 } 10056 *v = sv 10057 return nil 10058} 10059 10060func awsAwsjson10_deserializeOpDocumentCountPendingActivityTasksOutput(v **CountPendingActivityTasksOutput, value interface{}) error { 10061 if v == nil { 10062 return fmt.Errorf("unexpected nil of type %T", v) 10063 } 10064 if value == nil { 10065 return nil 10066 } 10067 10068 shape, ok := value.(map[string]interface{}) 10069 if !ok { 10070 return fmt.Errorf("unexpected JSON type %v", value) 10071 } 10072 10073 var sv *CountPendingActivityTasksOutput 10074 if *v == nil { 10075 sv = &CountPendingActivityTasksOutput{} 10076 } else { 10077 sv = *v 10078 } 10079 10080 for key, value := range shape { 10081 switch key { 10082 case "count": 10083 if value != nil { 10084 jtv, ok := value.(json.Number) 10085 if !ok { 10086 return fmt.Errorf("expected Count to be json.Number, got %T instead", value) 10087 } 10088 i64, err := jtv.Int64() 10089 if err != nil { 10090 return err 10091 } 10092 sv.Count = int32(i64) 10093 } 10094 10095 case "truncated": 10096 if value != nil { 10097 jtv, ok := value.(bool) 10098 if !ok { 10099 return fmt.Errorf("expected Truncated to be of type *bool, got %T instead", value) 10100 } 10101 sv.Truncated = jtv 10102 } 10103 10104 default: 10105 _, _ = key, value 10106 10107 } 10108 } 10109 *v = sv 10110 return nil 10111} 10112 10113func awsAwsjson10_deserializeOpDocumentCountPendingDecisionTasksOutput(v **CountPendingDecisionTasksOutput, value interface{}) error { 10114 if v == nil { 10115 return fmt.Errorf("unexpected nil of type %T", v) 10116 } 10117 if value == nil { 10118 return nil 10119 } 10120 10121 shape, ok := value.(map[string]interface{}) 10122 if !ok { 10123 return fmt.Errorf("unexpected JSON type %v", value) 10124 } 10125 10126 var sv *CountPendingDecisionTasksOutput 10127 if *v == nil { 10128 sv = &CountPendingDecisionTasksOutput{} 10129 } else { 10130 sv = *v 10131 } 10132 10133 for key, value := range shape { 10134 switch key { 10135 case "count": 10136 if value != nil { 10137 jtv, ok := value.(json.Number) 10138 if !ok { 10139 return fmt.Errorf("expected Count to be json.Number, got %T instead", value) 10140 } 10141 i64, err := jtv.Int64() 10142 if err != nil { 10143 return err 10144 } 10145 sv.Count = int32(i64) 10146 } 10147 10148 case "truncated": 10149 if value != nil { 10150 jtv, ok := value.(bool) 10151 if !ok { 10152 return fmt.Errorf("expected Truncated to be of type *bool, got %T instead", value) 10153 } 10154 sv.Truncated = jtv 10155 } 10156 10157 default: 10158 _, _ = key, value 10159 10160 } 10161 } 10162 *v = sv 10163 return nil 10164} 10165 10166func awsAwsjson10_deserializeOpDocumentDescribeActivityTypeOutput(v **DescribeActivityTypeOutput, value interface{}) error { 10167 if v == nil { 10168 return fmt.Errorf("unexpected nil of type %T", v) 10169 } 10170 if value == nil { 10171 return nil 10172 } 10173 10174 shape, ok := value.(map[string]interface{}) 10175 if !ok { 10176 return fmt.Errorf("unexpected JSON type %v", value) 10177 } 10178 10179 var sv *DescribeActivityTypeOutput 10180 if *v == nil { 10181 sv = &DescribeActivityTypeOutput{} 10182 } else { 10183 sv = *v 10184 } 10185 10186 for key, value := range shape { 10187 switch key { 10188 case "configuration": 10189 if err := awsAwsjson10_deserializeDocumentActivityTypeConfiguration(&sv.Configuration, value); err != nil { 10190 return err 10191 } 10192 10193 case "typeInfo": 10194 if err := awsAwsjson10_deserializeDocumentActivityTypeInfo(&sv.TypeInfo, value); err != nil { 10195 return err 10196 } 10197 10198 default: 10199 _, _ = key, value 10200 10201 } 10202 } 10203 *v = sv 10204 return nil 10205} 10206 10207func awsAwsjson10_deserializeOpDocumentDescribeDomainOutput(v **DescribeDomainOutput, value interface{}) error { 10208 if v == nil { 10209 return fmt.Errorf("unexpected nil of type %T", v) 10210 } 10211 if value == nil { 10212 return nil 10213 } 10214 10215 shape, ok := value.(map[string]interface{}) 10216 if !ok { 10217 return fmt.Errorf("unexpected JSON type %v", value) 10218 } 10219 10220 var sv *DescribeDomainOutput 10221 if *v == nil { 10222 sv = &DescribeDomainOutput{} 10223 } else { 10224 sv = *v 10225 } 10226 10227 for key, value := range shape { 10228 switch key { 10229 case "configuration": 10230 if err := awsAwsjson10_deserializeDocumentDomainConfiguration(&sv.Configuration, value); err != nil { 10231 return err 10232 } 10233 10234 case "domainInfo": 10235 if err := awsAwsjson10_deserializeDocumentDomainInfo(&sv.DomainInfo, value); err != nil { 10236 return err 10237 } 10238 10239 default: 10240 _, _ = key, value 10241 10242 } 10243 } 10244 *v = sv 10245 return nil 10246} 10247 10248func awsAwsjson10_deserializeOpDocumentDescribeWorkflowExecutionOutput(v **DescribeWorkflowExecutionOutput, value interface{}) error { 10249 if v == nil { 10250 return fmt.Errorf("unexpected nil of type %T", v) 10251 } 10252 if value == nil { 10253 return nil 10254 } 10255 10256 shape, ok := value.(map[string]interface{}) 10257 if !ok { 10258 return fmt.Errorf("unexpected JSON type %v", value) 10259 } 10260 10261 var sv *DescribeWorkflowExecutionOutput 10262 if *v == nil { 10263 sv = &DescribeWorkflowExecutionOutput{} 10264 } else { 10265 sv = *v 10266 } 10267 10268 for key, value := range shape { 10269 switch key { 10270 case "executionConfiguration": 10271 if err := awsAwsjson10_deserializeDocumentWorkflowExecutionConfiguration(&sv.ExecutionConfiguration, value); err != nil { 10272 return err 10273 } 10274 10275 case "executionInfo": 10276 if err := awsAwsjson10_deserializeDocumentWorkflowExecutionInfo(&sv.ExecutionInfo, value); err != nil { 10277 return err 10278 } 10279 10280 case "latestActivityTaskTimestamp": 10281 if value != nil { 10282 jtv, ok := value.(json.Number) 10283 if !ok { 10284 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 10285 } 10286 f64, err := jtv.Float64() 10287 if err != nil { 10288 return err 10289 } 10290 sv.LatestActivityTaskTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10291 } 10292 10293 case "latestExecutionContext": 10294 if value != nil { 10295 jtv, ok := value.(string) 10296 if !ok { 10297 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 10298 } 10299 sv.LatestExecutionContext = ptr.String(jtv) 10300 } 10301 10302 case "openCounts": 10303 if err := awsAwsjson10_deserializeDocumentWorkflowExecutionOpenCounts(&sv.OpenCounts, value); err != nil { 10304 return err 10305 } 10306 10307 default: 10308 _, _ = key, value 10309 10310 } 10311 } 10312 *v = sv 10313 return nil 10314} 10315 10316func awsAwsjson10_deserializeOpDocumentDescribeWorkflowTypeOutput(v **DescribeWorkflowTypeOutput, value interface{}) error { 10317 if v == nil { 10318 return fmt.Errorf("unexpected nil of type %T", v) 10319 } 10320 if value == nil { 10321 return nil 10322 } 10323 10324 shape, ok := value.(map[string]interface{}) 10325 if !ok { 10326 return fmt.Errorf("unexpected JSON type %v", value) 10327 } 10328 10329 var sv *DescribeWorkflowTypeOutput 10330 if *v == nil { 10331 sv = &DescribeWorkflowTypeOutput{} 10332 } else { 10333 sv = *v 10334 } 10335 10336 for key, value := range shape { 10337 switch key { 10338 case "configuration": 10339 if err := awsAwsjson10_deserializeDocumentWorkflowTypeConfiguration(&sv.Configuration, value); err != nil { 10340 return err 10341 } 10342 10343 case "typeInfo": 10344 if err := awsAwsjson10_deserializeDocumentWorkflowTypeInfo(&sv.TypeInfo, value); err != nil { 10345 return err 10346 } 10347 10348 default: 10349 _, _ = key, value 10350 10351 } 10352 } 10353 *v = sv 10354 return nil 10355} 10356 10357func awsAwsjson10_deserializeOpDocumentGetWorkflowExecutionHistoryOutput(v **GetWorkflowExecutionHistoryOutput, value interface{}) error { 10358 if v == nil { 10359 return fmt.Errorf("unexpected nil of type %T", v) 10360 } 10361 if value == nil { 10362 return nil 10363 } 10364 10365 shape, ok := value.(map[string]interface{}) 10366 if !ok { 10367 return fmt.Errorf("unexpected JSON type %v", value) 10368 } 10369 10370 var sv *GetWorkflowExecutionHistoryOutput 10371 if *v == nil { 10372 sv = &GetWorkflowExecutionHistoryOutput{} 10373 } else { 10374 sv = *v 10375 } 10376 10377 for key, value := range shape { 10378 switch key { 10379 case "events": 10380 if err := awsAwsjson10_deserializeDocumentHistoryEventList(&sv.Events, value); err != nil { 10381 return err 10382 } 10383 10384 case "nextPageToken": 10385 if value != nil { 10386 jtv, ok := value.(string) 10387 if !ok { 10388 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 10389 } 10390 sv.NextPageToken = ptr.String(jtv) 10391 } 10392 10393 default: 10394 _, _ = key, value 10395 10396 } 10397 } 10398 *v = sv 10399 return nil 10400} 10401 10402func awsAwsjson10_deserializeOpDocumentListActivityTypesOutput(v **ListActivityTypesOutput, value interface{}) error { 10403 if v == nil { 10404 return fmt.Errorf("unexpected nil of type %T", v) 10405 } 10406 if value == nil { 10407 return nil 10408 } 10409 10410 shape, ok := value.(map[string]interface{}) 10411 if !ok { 10412 return fmt.Errorf("unexpected JSON type %v", value) 10413 } 10414 10415 var sv *ListActivityTypesOutput 10416 if *v == nil { 10417 sv = &ListActivityTypesOutput{} 10418 } else { 10419 sv = *v 10420 } 10421 10422 for key, value := range shape { 10423 switch key { 10424 case "nextPageToken": 10425 if value != nil { 10426 jtv, ok := value.(string) 10427 if !ok { 10428 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 10429 } 10430 sv.NextPageToken = ptr.String(jtv) 10431 } 10432 10433 case "typeInfos": 10434 if err := awsAwsjson10_deserializeDocumentActivityTypeInfoList(&sv.TypeInfos, value); err != nil { 10435 return err 10436 } 10437 10438 default: 10439 _, _ = key, value 10440 10441 } 10442 } 10443 *v = sv 10444 return nil 10445} 10446 10447func awsAwsjson10_deserializeOpDocumentListClosedWorkflowExecutionsOutput(v **ListClosedWorkflowExecutionsOutput, value interface{}) error { 10448 if v == nil { 10449 return fmt.Errorf("unexpected nil of type %T", v) 10450 } 10451 if value == nil { 10452 return nil 10453 } 10454 10455 shape, ok := value.(map[string]interface{}) 10456 if !ok { 10457 return fmt.Errorf("unexpected JSON type %v", value) 10458 } 10459 10460 var sv *ListClosedWorkflowExecutionsOutput 10461 if *v == nil { 10462 sv = &ListClosedWorkflowExecutionsOutput{} 10463 } else { 10464 sv = *v 10465 } 10466 10467 for key, value := range shape { 10468 switch key { 10469 case "executionInfos": 10470 if err := awsAwsjson10_deserializeDocumentWorkflowExecutionInfoList(&sv.ExecutionInfos, value); err != nil { 10471 return err 10472 } 10473 10474 case "nextPageToken": 10475 if value != nil { 10476 jtv, ok := value.(string) 10477 if !ok { 10478 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 10479 } 10480 sv.NextPageToken = ptr.String(jtv) 10481 } 10482 10483 default: 10484 _, _ = key, value 10485 10486 } 10487 } 10488 *v = sv 10489 return nil 10490} 10491 10492func awsAwsjson10_deserializeOpDocumentListDomainsOutput(v **ListDomainsOutput, value interface{}) error { 10493 if v == nil { 10494 return fmt.Errorf("unexpected nil of type %T", v) 10495 } 10496 if value == nil { 10497 return nil 10498 } 10499 10500 shape, ok := value.(map[string]interface{}) 10501 if !ok { 10502 return fmt.Errorf("unexpected JSON type %v", value) 10503 } 10504 10505 var sv *ListDomainsOutput 10506 if *v == nil { 10507 sv = &ListDomainsOutput{} 10508 } else { 10509 sv = *v 10510 } 10511 10512 for key, value := range shape { 10513 switch key { 10514 case "domainInfos": 10515 if err := awsAwsjson10_deserializeDocumentDomainInfoList(&sv.DomainInfos, value); err != nil { 10516 return err 10517 } 10518 10519 case "nextPageToken": 10520 if value != nil { 10521 jtv, ok := value.(string) 10522 if !ok { 10523 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 10524 } 10525 sv.NextPageToken = ptr.String(jtv) 10526 } 10527 10528 default: 10529 _, _ = key, value 10530 10531 } 10532 } 10533 *v = sv 10534 return nil 10535} 10536 10537func awsAwsjson10_deserializeOpDocumentListOpenWorkflowExecutionsOutput(v **ListOpenWorkflowExecutionsOutput, value interface{}) error { 10538 if v == nil { 10539 return fmt.Errorf("unexpected nil of type %T", v) 10540 } 10541 if value == nil { 10542 return nil 10543 } 10544 10545 shape, ok := value.(map[string]interface{}) 10546 if !ok { 10547 return fmt.Errorf("unexpected JSON type %v", value) 10548 } 10549 10550 var sv *ListOpenWorkflowExecutionsOutput 10551 if *v == nil { 10552 sv = &ListOpenWorkflowExecutionsOutput{} 10553 } else { 10554 sv = *v 10555 } 10556 10557 for key, value := range shape { 10558 switch key { 10559 case "executionInfos": 10560 if err := awsAwsjson10_deserializeDocumentWorkflowExecutionInfoList(&sv.ExecutionInfos, value); err != nil { 10561 return err 10562 } 10563 10564 case "nextPageToken": 10565 if value != nil { 10566 jtv, ok := value.(string) 10567 if !ok { 10568 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 10569 } 10570 sv.NextPageToken = ptr.String(jtv) 10571 } 10572 10573 default: 10574 _, _ = key, value 10575 10576 } 10577 } 10578 *v = sv 10579 return nil 10580} 10581 10582func awsAwsjson10_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 10583 if v == nil { 10584 return fmt.Errorf("unexpected nil of type %T", v) 10585 } 10586 if value == nil { 10587 return nil 10588 } 10589 10590 shape, ok := value.(map[string]interface{}) 10591 if !ok { 10592 return fmt.Errorf("unexpected JSON type %v", value) 10593 } 10594 10595 var sv *ListTagsForResourceOutput 10596 if *v == nil { 10597 sv = &ListTagsForResourceOutput{} 10598 } else { 10599 sv = *v 10600 } 10601 10602 for key, value := range shape { 10603 switch key { 10604 case "tags": 10605 if err := awsAwsjson10_deserializeDocumentResourceTagList(&sv.Tags, value); err != nil { 10606 return err 10607 } 10608 10609 default: 10610 _, _ = key, value 10611 10612 } 10613 } 10614 *v = sv 10615 return nil 10616} 10617 10618func awsAwsjson10_deserializeOpDocumentListWorkflowTypesOutput(v **ListWorkflowTypesOutput, value interface{}) error { 10619 if v == nil { 10620 return fmt.Errorf("unexpected nil of type %T", v) 10621 } 10622 if value == nil { 10623 return nil 10624 } 10625 10626 shape, ok := value.(map[string]interface{}) 10627 if !ok { 10628 return fmt.Errorf("unexpected JSON type %v", value) 10629 } 10630 10631 var sv *ListWorkflowTypesOutput 10632 if *v == nil { 10633 sv = &ListWorkflowTypesOutput{} 10634 } else { 10635 sv = *v 10636 } 10637 10638 for key, value := range shape { 10639 switch key { 10640 case "nextPageToken": 10641 if value != nil { 10642 jtv, ok := value.(string) 10643 if !ok { 10644 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 10645 } 10646 sv.NextPageToken = ptr.String(jtv) 10647 } 10648 10649 case "typeInfos": 10650 if err := awsAwsjson10_deserializeDocumentWorkflowTypeInfoList(&sv.TypeInfos, value); err != nil { 10651 return err 10652 } 10653 10654 default: 10655 _, _ = key, value 10656 10657 } 10658 } 10659 *v = sv 10660 return nil 10661} 10662 10663func awsAwsjson10_deserializeOpDocumentPollForActivityTaskOutput(v **PollForActivityTaskOutput, value interface{}) error { 10664 if v == nil { 10665 return fmt.Errorf("unexpected nil of type %T", v) 10666 } 10667 if value == nil { 10668 return nil 10669 } 10670 10671 shape, ok := value.(map[string]interface{}) 10672 if !ok { 10673 return fmt.Errorf("unexpected JSON type %v", value) 10674 } 10675 10676 var sv *PollForActivityTaskOutput 10677 if *v == nil { 10678 sv = &PollForActivityTaskOutput{} 10679 } else { 10680 sv = *v 10681 } 10682 10683 for key, value := range shape { 10684 switch key { 10685 case "activityId": 10686 if value != nil { 10687 jtv, ok := value.(string) 10688 if !ok { 10689 return fmt.Errorf("expected ActivityId to be of type string, got %T instead", value) 10690 } 10691 sv.ActivityId = ptr.String(jtv) 10692 } 10693 10694 case "activityType": 10695 if err := awsAwsjson10_deserializeDocumentActivityType(&sv.ActivityType, value); err != nil { 10696 return err 10697 } 10698 10699 case "input": 10700 if value != nil { 10701 jtv, ok := value.(string) 10702 if !ok { 10703 return fmt.Errorf("expected Data to be of type string, got %T instead", value) 10704 } 10705 sv.Input = ptr.String(jtv) 10706 } 10707 10708 case "startedEventId": 10709 if value != nil { 10710 jtv, ok := value.(json.Number) 10711 if !ok { 10712 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 10713 } 10714 i64, err := jtv.Int64() 10715 if err != nil { 10716 return err 10717 } 10718 sv.StartedEventId = i64 10719 } 10720 10721 case "taskToken": 10722 if value != nil { 10723 jtv, ok := value.(string) 10724 if !ok { 10725 return fmt.Errorf("expected TaskToken to be of type string, got %T instead", value) 10726 } 10727 sv.TaskToken = ptr.String(jtv) 10728 } 10729 10730 case "workflowExecution": 10731 if err := awsAwsjson10_deserializeDocumentWorkflowExecution(&sv.WorkflowExecution, value); err != nil { 10732 return err 10733 } 10734 10735 default: 10736 _, _ = key, value 10737 10738 } 10739 } 10740 *v = sv 10741 return nil 10742} 10743 10744func awsAwsjson10_deserializeOpDocumentPollForDecisionTaskOutput(v **PollForDecisionTaskOutput, value interface{}) error { 10745 if v == nil { 10746 return fmt.Errorf("unexpected nil of type %T", v) 10747 } 10748 if value == nil { 10749 return nil 10750 } 10751 10752 shape, ok := value.(map[string]interface{}) 10753 if !ok { 10754 return fmt.Errorf("unexpected JSON type %v", value) 10755 } 10756 10757 var sv *PollForDecisionTaskOutput 10758 if *v == nil { 10759 sv = &PollForDecisionTaskOutput{} 10760 } else { 10761 sv = *v 10762 } 10763 10764 for key, value := range shape { 10765 switch key { 10766 case "events": 10767 if err := awsAwsjson10_deserializeDocumentHistoryEventList(&sv.Events, value); err != nil { 10768 return err 10769 } 10770 10771 case "nextPageToken": 10772 if value != nil { 10773 jtv, ok := value.(string) 10774 if !ok { 10775 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 10776 } 10777 sv.NextPageToken = ptr.String(jtv) 10778 } 10779 10780 case "previousStartedEventId": 10781 if value != nil { 10782 jtv, ok := value.(json.Number) 10783 if !ok { 10784 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 10785 } 10786 i64, err := jtv.Int64() 10787 if err != nil { 10788 return err 10789 } 10790 sv.PreviousStartedEventId = i64 10791 } 10792 10793 case "startedEventId": 10794 if value != nil { 10795 jtv, ok := value.(json.Number) 10796 if !ok { 10797 return fmt.Errorf("expected EventId to be json.Number, got %T instead", value) 10798 } 10799 i64, err := jtv.Int64() 10800 if err != nil { 10801 return err 10802 } 10803 sv.StartedEventId = i64 10804 } 10805 10806 case "taskToken": 10807 if value != nil { 10808 jtv, ok := value.(string) 10809 if !ok { 10810 return fmt.Errorf("expected TaskToken to be of type string, got %T instead", value) 10811 } 10812 sv.TaskToken = ptr.String(jtv) 10813 } 10814 10815 case "workflowExecution": 10816 if err := awsAwsjson10_deserializeDocumentWorkflowExecution(&sv.WorkflowExecution, value); err != nil { 10817 return err 10818 } 10819 10820 case "workflowType": 10821 if err := awsAwsjson10_deserializeDocumentWorkflowType(&sv.WorkflowType, value); err != nil { 10822 return err 10823 } 10824 10825 default: 10826 _, _ = key, value 10827 10828 } 10829 } 10830 *v = sv 10831 return nil 10832} 10833 10834func awsAwsjson10_deserializeOpDocumentRecordActivityTaskHeartbeatOutput(v **RecordActivityTaskHeartbeatOutput, value interface{}) error { 10835 if v == nil { 10836 return fmt.Errorf("unexpected nil of type %T", v) 10837 } 10838 if value == nil { 10839 return nil 10840 } 10841 10842 shape, ok := value.(map[string]interface{}) 10843 if !ok { 10844 return fmt.Errorf("unexpected JSON type %v", value) 10845 } 10846 10847 var sv *RecordActivityTaskHeartbeatOutput 10848 if *v == nil { 10849 sv = &RecordActivityTaskHeartbeatOutput{} 10850 } else { 10851 sv = *v 10852 } 10853 10854 for key, value := range shape { 10855 switch key { 10856 case "cancelRequested": 10857 if value != nil { 10858 jtv, ok := value.(bool) 10859 if !ok { 10860 return fmt.Errorf("expected Canceled to be of type *bool, got %T instead", value) 10861 } 10862 sv.CancelRequested = jtv 10863 } 10864 10865 default: 10866 _, _ = key, value 10867 10868 } 10869 } 10870 *v = sv 10871 return nil 10872} 10873 10874func awsAwsjson10_deserializeOpDocumentStartWorkflowExecutionOutput(v **StartWorkflowExecutionOutput, value interface{}) error { 10875 if v == nil { 10876 return fmt.Errorf("unexpected nil of type %T", v) 10877 } 10878 if value == nil { 10879 return nil 10880 } 10881 10882 shape, ok := value.(map[string]interface{}) 10883 if !ok { 10884 return fmt.Errorf("unexpected JSON type %v", value) 10885 } 10886 10887 var sv *StartWorkflowExecutionOutput 10888 if *v == nil { 10889 sv = &StartWorkflowExecutionOutput{} 10890 } else { 10891 sv = *v 10892 } 10893 10894 for key, value := range shape { 10895 switch key { 10896 case "runId": 10897 if value != nil { 10898 jtv, ok := value.(string) 10899 if !ok { 10900 return fmt.Errorf("expected WorkflowRunId to be of type string, got %T instead", value) 10901 } 10902 sv.RunId = ptr.String(jtv) 10903 } 10904 10905 default: 10906 _, _ = key, value 10907 10908 } 10909 } 10910 *v = sv 10911 return nil 10912} 10913