1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package mediaconvert 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/mediaconvert/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 "math" 20 "strings" 21) 22 23type awsRestjson1_deserializeOpAssociateCertificate struct { 24} 25 26func (*awsRestjson1_deserializeOpAssociateCertificate) ID() string { 27 return "OperationDeserializer" 28} 29 30func (m *awsRestjson1_deserializeOpAssociateCertificate) 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, awsRestjson1_deserializeOpErrorAssociateCertificate(response, &metadata) 45 } 46 output := &AssociateCertificateOutput{} 47 out.Result = output 48 49 return out, metadata, err 50} 51 52func awsRestjson1_deserializeOpErrorAssociateCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 53 var errorBuffer bytes.Buffer 54 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 55 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 56 } 57 errorBody := bytes.NewReader(errorBuffer.Bytes()) 58 59 errorCode := "UnknownError" 60 errorMessage := errorCode 61 62 code := response.Header.Get("X-Amzn-ErrorType") 63 if len(code) != 0 { 64 errorCode = restjson.SanitizeErrorCode(code) 65 } 66 67 var buff [1024]byte 68 ringBuffer := smithyio.NewRingBuffer(buff[:]) 69 70 body := io.TeeReader(errorBody, ringBuffer) 71 decoder := json.NewDecoder(body) 72 decoder.UseNumber() 73 code, message, err := restjson.GetErrorInfo(decoder) 74 if err != nil { 75 var snapshot bytes.Buffer 76 io.Copy(&snapshot, ringBuffer) 77 err = &smithy.DeserializationError{ 78 Err: fmt.Errorf("failed to decode response body, %w", err), 79 Snapshot: snapshot.Bytes(), 80 } 81 return err 82 } 83 84 errorBody.Seek(0, io.SeekStart) 85 if len(code) != 0 { 86 errorCode = restjson.SanitizeErrorCode(code) 87 } 88 if len(message) != 0 { 89 errorMessage = message 90 } 91 92 switch { 93 case strings.EqualFold("BadRequestException", errorCode): 94 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 95 96 case strings.EqualFold("ConflictException", errorCode): 97 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 98 99 case strings.EqualFold("ForbiddenException", errorCode): 100 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 101 102 case strings.EqualFold("InternalServerErrorException", errorCode): 103 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 104 105 case strings.EqualFold("NotFoundException", errorCode): 106 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 107 108 case strings.EqualFold("TooManyRequestsException", errorCode): 109 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 110 111 default: 112 genericError := &smithy.GenericAPIError{ 113 Code: errorCode, 114 Message: errorMessage, 115 } 116 return genericError 117 118 } 119} 120 121type awsRestjson1_deserializeOpCancelJob struct { 122} 123 124func (*awsRestjson1_deserializeOpCancelJob) ID() string { 125 return "OperationDeserializer" 126} 127 128func (m *awsRestjson1_deserializeOpCancelJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 129 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 130) { 131 out, metadata, err = next.HandleDeserialize(ctx, in) 132 if err != nil { 133 return out, metadata, err 134 } 135 136 response, ok := out.RawResponse.(*smithyhttp.Response) 137 if !ok { 138 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 139 } 140 141 if response.StatusCode < 200 || response.StatusCode >= 300 { 142 return out, metadata, awsRestjson1_deserializeOpErrorCancelJob(response, &metadata) 143 } 144 output := &CancelJobOutput{} 145 out.Result = output 146 147 return out, metadata, err 148} 149 150func awsRestjson1_deserializeOpErrorCancelJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 151 var errorBuffer bytes.Buffer 152 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 153 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 154 } 155 errorBody := bytes.NewReader(errorBuffer.Bytes()) 156 157 errorCode := "UnknownError" 158 errorMessage := errorCode 159 160 code := response.Header.Get("X-Amzn-ErrorType") 161 if len(code) != 0 { 162 errorCode = restjson.SanitizeErrorCode(code) 163 } 164 165 var buff [1024]byte 166 ringBuffer := smithyio.NewRingBuffer(buff[:]) 167 168 body := io.TeeReader(errorBody, ringBuffer) 169 decoder := json.NewDecoder(body) 170 decoder.UseNumber() 171 code, message, err := restjson.GetErrorInfo(decoder) 172 if err != nil { 173 var snapshot bytes.Buffer 174 io.Copy(&snapshot, ringBuffer) 175 err = &smithy.DeserializationError{ 176 Err: fmt.Errorf("failed to decode response body, %w", err), 177 Snapshot: snapshot.Bytes(), 178 } 179 return err 180 } 181 182 errorBody.Seek(0, io.SeekStart) 183 if len(code) != 0 { 184 errorCode = restjson.SanitizeErrorCode(code) 185 } 186 if len(message) != 0 { 187 errorMessage = message 188 } 189 190 switch { 191 case strings.EqualFold("BadRequestException", errorCode): 192 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 193 194 case strings.EqualFold("ConflictException", errorCode): 195 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 196 197 case strings.EqualFold("ForbiddenException", errorCode): 198 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 199 200 case strings.EqualFold("InternalServerErrorException", errorCode): 201 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 202 203 case strings.EqualFold("NotFoundException", errorCode): 204 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 205 206 case strings.EqualFold("TooManyRequestsException", errorCode): 207 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 208 209 default: 210 genericError := &smithy.GenericAPIError{ 211 Code: errorCode, 212 Message: errorMessage, 213 } 214 return genericError 215 216 } 217} 218 219type awsRestjson1_deserializeOpCreateJob struct { 220} 221 222func (*awsRestjson1_deserializeOpCreateJob) ID() string { 223 return "OperationDeserializer" 224} 225 226func (m *awsRestjson1_deserializeOpCreateJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 227 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 228) { 229 out, metadata, err = next.HandleDeserialize(ctx, in) 230 if err != nil { 231 return out, metadata, err 232 } 233 234 response, ok := out.RawResponse.(*smithyhttp.Response) 235 if !ok { 236 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 237 } 238 239 if response.StatusCode < 200 || response.StatusCode >= 300 { 240 return out, metadata, awsRestjson1_deserializeOpErrorCreateJob(response, &metadata) 241 } 242 output := &CreateJobOutput{} 243 out.Result = output 244 245 var buff [1024]byte 246 ringBuffer := smithyio.NewRingBuffer(buff[:]) 247 248 body := io.TeeReader(response.Body, ringBuffer) 249 250 decoder := json.NewDecoder(body) 251 decoder.UseNumber() 252 var shape interface{} 253 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 254 var snapshot bytes.Buffer 255 io.Copy(&snapshot, ringBuffer) 256 err = &smithy.DeserializationError{ 257 Err: fmt.Errorf("failed to decode response body, %w", err), 258 Snapshot: snapshot.Bytes(), 259 } 260 return out, metadata, err 261 } 262 263 err = awsRestjson1_deserializeOpDocumentCreateJobOutput(&output, shape) 264 if err != nil { 265 var snapshot bytes.Buffer 266 io.Copy(&snapshot, ringBuffer) 267 return out, metadata, &smithy.DeserializationError{ 268 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 269 Snapshot: snapshot.Bytes(), 270 } 271 } 272 273 return out, metadata, err 274} 275 276func awsRestjson1_deserializeOpErrorCreateJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 277 var errorBuffer bytes.Buffer 278 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 279 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 280 } 281 errorBody := bytes.NewReader(errorBuffer.Bytes()) 282 283 errorCode := "UnknownError" 284 errorMessage := errorCode 285 286 code := response.Header.Get("X-Amzn-ErrorType") 287 if len(code) != 0 { 288 errorCode = restjson.SanitizeErrorCode(code) 289 } 290 291 var buff [1024]byte 292 ringBuffer := smithyio.NewRingBuffer(buff[:]) 293 294 body := io.TeeReader(errorBody, ringBuffer) 295 decoder := json.NewDecoder(body) 296 decoder.UseNumber() 297 code, message, err := restjson.GetErrorInfo(decoder) 298 if err != nil { 299 var snapshot bytes.Buffer 300 io.Copy(&snapshot, ringBuffer) 301 err = &smithy.DeserializationError{ 302 Err: fmt.Errorf("failed to decode response body, %w", err), 303 Snapshot: snapshot.Bytes(), 304 } 305 return err 306 } 307 308 errorBody.Seek(0, io.SeekStart) 309 if len(code) != 0 { 310 errorCode = restjson.SanitizeErrorCode(code) 311 } 312 if len(message) != 0 { 313 errorMessage = message 314 } 315 316 switch { 317 case strings.EqualFold("BadRequestException", errorCode): 318 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 319 320 case strings.EqualFold("ConflictException", errorCode): 321 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 322 323 case strings.EqualFold("ForbiddenException", errorCode): 324 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 325 326 case strings.EqualFold("InternalServerErrorException", errorCode): 327 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 328 329 case strings.EqualFold("NotFoundException", errorCode): 330 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 331 332 case strings.EqualFold("TooManyRequestsException", errorCode): 333 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 334 335 default: 336 genericError := &smithy.GenericAPIError{ 337 Code: errorCode, 338 Message: errorMessage, 339 } 340 return genericError 341 342 } 343} 344 345func awsRestjson1_deserializeOpDocumentCreateJobOutput(v **CreateJobOutput, value interface{}) error { 346 if v == nil { 347 return fmt.Errorf("unexpected nil of type %T", v) 348 } 349 if value == nil { 350 return nil 351 } 352 353 shape, ok := value.(map[string]interface{}) 354 if !ok { 355 return fmt.Errorf("unexpected JSON type %v", value) 356 } 357 358 var sv *CreateJobOutput 359 if *v == nil { 360 sv = &CreateJobOutput{} 361 } else { 362 sv = *v 363 } 364 365 for key, value := range shape { 366 switch key { 367 case "job": 368 if err := awsRestjson1_deserializeDocumentJob(&sv.Job, value); err != nil { 369 return err 370 } 371 372 default: 373 _, _ = key, value 374 375 } 376 } 377 *v = sv 378 return nil 379} 380 381type awsRestjson1_deserializeOpCreateJobTemplate struct { 382} 383 384func (*awsRestjson1_deserializeOpCreateJobTemplate) ID() string { 385 return "OperationDeserializer" 386} 387 388func (m *awsRestjson1_deserializeOpCreateJobTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 389 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 390) { 391 out, metadata, err = next.HandleDeserialize(ctx, in) 392 if err != nil { 393 return out, metadata, err 394 } 395 396 response, ok := out.RawResponse.(*smithyhttp.Response) 397 if !ok { 398 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 399 } 400 401 if response.StatusCode < 200 || response.StatusCode >= 300 { 402 return out, metadata, awsRestjson1_deserializeOpErrorCreateJobTemplate(response, &metadata) 403 } 404 output := &CreateJobTemplateOutput{} 405 out.Result = output 406 407 var buff [1024]byte 408 ringBuffer := smithyio.NewRingBuffer(buff[:]) 409 410 body := io.TeeReader(response.Body, ringBuffer) 411 412 decoder := json.NewDecoder(body) 413 decoder.UseNumber() 414 var shape interface{} 415 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 416 var snapshot bytes.Buffer 417 io.Copy(&snapshot, ringBuffer) 418 err = &smithy.DeserializationError{ 419 Err: fmt.Errorf("failed to decode response body, %w", err), 420 Snapshot: snapshot.Bytes(), 421 } 422 return out, metadata, err 423 } 424 425 err = awsRestjson1_deserializeOpDocumentCreateJobTemplateOutput(&output, shape) 426 if err != nil { 427 var snapshot bytes.Buffer 428 io.Copy(&snapshot, ringBuffer) 429 return out, metadata, &smithy.DeserializationError{ 430 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 431 Snapshot: snapshot.Bytes(), 432 } 433 } 434 435 return out, metadata, err 436} 437 438func awsRestjson1_deserializeOpErrorCreateJobTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 439 var errorBuffer bytes.Buffer 440 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 441 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 442 } 443 errorBody := bytes.NewReader(errorBuffer.Bytes()) 444 445 errorCode := "UnknownError" 446 errorMessage := errorCode 447 448 code := response.Header.Get("X-Amzn-ErrorType") 449 if len(code) != 0 { 450 errorCode = restjson.SanitizeErrorCode(code) 451 } 452 453 var buff [1024]byte 454 ringBuffer := smithyio.NewRingBuffer(buff[:]) 455 456 body := io.TeeReader(errorBody, ringBuffer) 457 decoder := json.NewDecoder(body) 458 decoder.UseNumber() 459 code, message, err := restjson.GetErrorInfo(decoder) 460 if err != nil { 461 var snapshot bytes.Buffer 462 io.Copy(&snapshot, ringBuffer) 463 err = &smithy.DeserializationError{ 464 Err: fmt.Errorf("failed to decode response body, %w", err), 465 Snapshot: snapshot.Bytes(), 466 } 467 return err 468 } 469 470 errorBody.Seek(0, io.SeekStart) 471 if len(code) != 0 { 472 errorCode = restjson.SanitizeErrorCode(code) 473 } 474 if len(message) != 0 { 475 errorMessage = message 476 } 477 478 switch { 479 case strings.EqualFold("BadRequestException", errorCode): 480 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 481 482 case strings.EqualFold("ConflictException", errorCode): 483 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 484 485 case strings.EqualFold("ForbiddenException", errorCode): 486 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 487 488 case strings.EqualFold("InternalServerErrorException", errorCode): 489 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 490 491 case strings.EqualFold("NotFoundException", errorCode): 492 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 493 494 case strings.EqualFold("TooManyRequestsException", errorCode): 495 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 496 497 default: 498 genericError := &smithy.GenericAPIError{ 499 Code: errorCode, 500 Message: errorMessage, 501 } 502 return genericError 503 504 } 505} 506 507func awsRestjson1_deserializeOpDocumentCreateJobTemplateOutput(v **CreateJobTemplateOutput, value interface{}) error { 508 if v == nil { 509 return fmt.Errorf("unexpected nil of type %T", v) 510 } 511 if value == nil { 512 return nil 513 } 514 515 shape, ok := value.(map[string]interface{}) 516 if !ok { 517 return fmt.Errorf("unexpected JSON type %v", value) 518 } 519 520 var sv *CreateJobTemplateOutput 521 if *v == nil { 522 sv = &CreateJobTemplateOutput{} 523 } else { 524 sv = *v 525 } 526 527 for key, value := range shape { 528 switch key { 529 case "jobTemplate": 530 if err := awsRestjson1_deserializeDocumentJobTemplate(&sv.JobTemplate, value); err != nil { 531 return err 532 } 533 534 default: 535 _, _ = key, value 536 537 } 538 } 539 *v = sv 540 return nil 541} 542 543type awsRestjson1_deserializeOpCreatePreset struct { 544} 545 546func (*awsRestjson1_deserializeOpCreatePreset) ID() string { 547 return "OperationDeserializer" 548} 549 550func (m *awsRestjson1_deserializeOpCreatePreset) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 551 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 552) { 553 out, metadata, err = next.HandleDeserialize(ctx, in) 554 if err != nil { 555 return out, metadata, err 556 } 557 558 response, ok := out.RawResponse.(*smithyhttp.Response) 559 if !ok { 560 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 561 } 562 563 if response.StatusCode < 200 || response.StatusCode >= 300 { 564 return out, metadata, awsRestjson1_deserializeOpErrorCreatePreset(response, &metadata) 565 } 566 output := &CreatePresetOutput{} 567 out.Result = output 568 569 var buff [1024]byte 570 ringBuffer := smithyio.NewRingBuffer(buff[:]) 571 572 body := io.TeeReader(response.Body, ringBuffer) 573 574 decoder := json.NewDecoder(body) 575 decoder.UseNumber() 576 var shape interface{} 577 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 578 var snapshot bytes.Buffer 579 io.Copy(&snapshot, ringBuffer) 580 err = &smithy.DeserializationError{ 581 Err: fmt.Errorf("failed to decode response body, %w", err), 582 Snapshot: snapshot.Bytes(), 583 } 584 return out, metadata, err 585 } 586 587 err = awsRestjson1_deserializeOpDocumentCreatePresetOutput(&output, shape) 588 if err != nil { 589 var snapshot bytes.Buffer 590 io.Copy(&snapshot, ringBuffer) 591 return out, metadata, &smithy.DeserializationError{ 592 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 593 Snapshot: snapshot.Bytes(), 594 } 595 } 596 597 return out, metadata, err 598} 599 600func awsRestjson1_deserializeOpErrorCreatePreset(response *smithyhttp.Response, metadata *middleware.Metadata) error { 601 var errorBuffer bytes.Buffer 602 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 603 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 604 } 605 errorBody := bytes.NewReader(errorBuffer.Bytes()) 606 607 errorCode := "UnknownError" 608 errorMessage := errorCode 609 610 code := response.Header.Get("X-Amzn-ErrorType") 611 if len(code) != 0 { 612 errorCode = restjson.SanitizeErrorCode(code) 613 } 614 615 var buff [1024]byte 616 ringBuffer := smithyio.NewRingBuffer(buff[:]) 617 618 body := io.TeeReader(errorBody, ringBuffer) 619 decoder := json.NewDecoder(body) 620 decoder.UseNumber() 621 code, message, err := restjson.GetErrorInfo(decoder) 622 if err != nil { 623 var snapshot bytes.Buffer 624 io.Copy(&snapshot, ringBuffer) 625 err = &smithy.DeserializationError{ 626 Err: fmt.Errorf("failed to decode response body, %w", err), 627 Snapshot: snapshot.Bytes(), 628 } 629 return err 630 } 631 632 errorBody.Seek(0, io.SeekStart) 633 if len(code) != 0 { 634 errorCode = restjson.SanitizeErrorCode(code) 635 } 636 if len(message) != 0 { 637 errorMessage = message 638 } 639 640 switch { 641 case strings.EqualFold("BadRequestException", errorCode): 642 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 643 644 case strings.EqualFold("ConflictException", errorCode): 645 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 646 647 case strings.EqualFold("ForbiddenException", errorCode): 648 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 649 650 case strings.EqualFold("InternalServerErrorException", errorCode): 651 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 652 653 case strings.EqualFold("NotFoundException", errorCode): 654 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 655 656 case strings.EqualFold("TooManyRequestsException", errorCode): 657 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 658 659 default: 660 genericError := &smithy.GenericAPIError{ 661 Code: errorCode, 662 Message: errorMessage, 663 } 664 return genericError 665 666 } 667} 668 669func awsRestjson1_deserializeOpDocumentCreatePresetOutput(v **CreatePresetOutput, value interface{}) error { 670 if v == nil { 671 return fmt.Errorf("unexpected nil of type %T", v) 672 } 673 if value == nil { 674 return nil 675 } 676 677 shape, ok := value.(map[string]interface{}) 678 if !ok { 679 return fmt.Errorf("unexpected JSON type %v", value) 680 } 681 682 var sv *CreatePresetOutput 683 if *v == nil { 684 sv = &CreatePresetOutput{} 685 } else { 686 sv = *v 687 } 688 689 for key, value := range shape { 690 switch key { 691 case "preset": 692 if err := awsRestjson1_deserializeDocumentPreset(&sv.Preset, value); err != nil { 693 return err 694 } 695 696 default: 697 _, _ = key, value 698 699 } 700 } 701 *v = sv 702 return nil 703} 704 705type awsRestjson1_deserializeOpCreateQueue struct { 706} 707 708func (*awsRestjson1_deserializeOpCreateQueue) ID() string { 709 return "OperationDeserializer" 710} 711 712func (m *awsRestjson1_deserializeOpCreateQueue) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 713 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 714) { 715 out, metadata, err = next.HandleDeserialize(ctx, in) 716 if err != nil { 717 return out, metadata, err 718 } 719 720 response, ok := out.RawResponse.(*smithyhttp.Response) 721 if !ok { 722 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 723 } 724 725 if response.StatusCode < 200 || response.StatusCode >= 300 { 726 return out, metadata, awsRestjson1_deserializeOpErrorCreateQueue(response, &metadata) 727 } 728 output := &CreateQueueOutput{} 729 out.Result = output 730 731 var buff [1024]byte 732 ringBuffer := smithyio.NewRingBuffer(buff[:]) 733 734 body := io.TeeReader(response.Body, ringBuffer) 735 736 decoder := json.NewDecoder(body) 737 decoder.UseNumber() 738 var shape interface{} 739 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 740 var snapshot bytes.Buffer 741 io.Copy(&snapshot, ringBuffer) 742 err = &smithy.DeserializationError{ 743 Err: fmt.Errorf("failed to decode response body, %w", err), 744 Snapshot: snapshot.Bytes(), 745 } 746 return out, metadata, err 747 } 748 749 err = awsRestjson1_deserializeOpDocumentCreateQueueOutput(&output, shape) 750 if err != nil { 751 var snapshot bytes.Buffer 752 io.Copy(&snapshot, ringBuffer) 753 return out, metadata, &smithy.DeserializationError{ 754 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 755 Snapshot: snapshot.Bytes(), 756 } 757 } 758 759 return out, metadata, err 760} 761 762func awsRestjson1_deserializeOpErrorCreateQueue(response *smithyhttp.Response, metadata *middleware.Metadata) error { 763 var errorBuffer bytes.Buffer 764 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 765 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 766 } 767 errorBody := bytes.NewReader(errorBuffer.Bytes()) 768 769 errorCode := "UnknownError" 770 errorMessage := errorCode 771 772 code := response.Header.Get("X-Amzn-ErrorType") 773 if len(code) != 0 { 774 errorCode = restjson.SanitizeErrorCode(code) 775 } 776 777 var buff [1024]byte 778 ringBuffer := smithyio.NewRingBuffer(buff[:]) 779 780 body := io.TeeReader(errorBody, ringBuffer) 781 decoder := json.NewDecoder(body) 782 decoder.UseNumber() 783 code, message, err := restjson.GetErrorInfo(decoder) 784 if err != nil { 785 var snapshot bytes.Buffer 786 io.Copy(&snapshot, ringBuffer) 787 err = &smithy.DeserializationError{ 788 Err: fmt.Errorf("failed to decode response body, %w", err), 789 Snapshot: snapshot.Bytes(), 790 } 791 return err 792 } 793 794 errorBody.Seek(0, io.SeekStart) 795 if len(code) != 0 { 796 errorCode = restjson.SanitizeErrorCode(code) 797 } 798 if len(message) != 0 { 799 errorMessage = message 800 } 801 802 switch { 803 case strings.EqualFold("BadRequestException", errorCode): 804 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 805 806 case strings.EqualFold("ConflictException", errorCode): 807 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 808 809 case strings.EqualFold("ForbiddenException", errorCode): 810 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 811 812 case strings.EqualFold("InternalServerErrorException", errorCode): 813 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 814 815 case strings.EqualFold("NotFoundException", errorCode): 816 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 817 818 case strings.EqualFold("TooManyRequestsException", errorCode): 819 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 820 821 default: 822 genericError := &smithy.GenericAPIError{ 823 Code: errorCode, 824 Message: errorMessage, 825 } 826 return genericError 827 828 } 829} 830 831func awsRestjson1_deserializeOpDocumentCreateQueueOutput(v **CreateQueueOutput, value interface{}) error { 832 if v == nil { 833 return fmt.Errorf("unexpected nil of type %T", v) 834 } 835 if value == nil { 836 return nil 837 } 838 839 shape, ok := value.(map[string]interface{}) 840 if !ok { 841 return fmt.Errorf("unexpected JSON type %v", value) 842 } 843 844 var sv *CreateQueueOutput 845 if *v == nil { 846 sv = &CreateQueueOutput{} 847 } else { 848 sv = *v 849 } 850 851 for key, value := range shape { 852 switch key { 853 case "queue": 854 if err := awsRestjson1_deserializeDocumentQueue(&sv.Queue, value); err != nil { 855 return err 856 } 857 858 default: 859 _, _ = key, value 860 861 } 862 } 863 *v = sv 864 return nil 865} 866 867type awsRestjson1_deserializeOpDeleteJobTemplate struct { 868} 869 870func (*awsRestjson1_deserializeOpDeleteJobTemplate) ID() string { 871 return "OperationDeserializer" 872} 873 874func (m *awsRestjson1_deserializeOpDeleteJobTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 875 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 876) { 877 out, metadata, err = next.HandleDeserialize(ctx, in) 878 if err != nil { 879 return out, metadata, err 880 } 881 882 response, ok := out.RawResponse.(*smithyhttp.Response) 883 if !ok { 884 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 885 } 886 887 if response.StatusCode < 200 || response.StatusCode >= 300 { 888 return out, metadata, awsRestjson1_deserializeOpErrorDeleteJobTemplate(response, &metadata) 889 } 890 output := &DeleteJobTemplateOutput{} 891 out.Result = output 892 893 return out, metadata, err 894} 895 896func awsRestjson1_deserializeOpErrorDeleteJobTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 897 var errorBuffer bytes.Buffer 898 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 899 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 900 } 901 errorBody := bytes.NewReader(errorBuffer.Bytes()) 902 903 errorCode := "UnknownError" 904 errorMessage := errorCode 905 906 code := response.Header.Get("X-Amzn-ErrorType") 907 if len(code) != 0 { 908 errorCode = restjson.SanitizeErrorCode(code) 909 } 910 911 var buff [1024]byte 912 ringBuffer := smithyio.NewRingBuffer(buff[:]) 913 914 body := io.TeeReader(errorBody, ringBuffer) 915 decoder := json.NewDecoder(body) 916 decoder.UseNumber() 917 code, message, err := restjson.GetErrorInfo(decoder) 918 if err != nil { 919 var snapshot bytes.Buffer 920 io.Copy(&snapshot, ringBuffer) 921 err = &smithy.DeserializationError{ 922 Err: fmt.Errorf("failed to decode response body, %w", err), 923 Snapshot: snapshot.Bytes(), 924 } 925 return err 926 } 927 928 errorBody.Seek(0, io.SeekStart) 929 if len(code) != 0 { 930 errorCode = restjson.SanitizeErrorCode(code) 931 } 932 if len(message) != 0 { 933 errorMessage = message 934 } 935 936 switch { 937 case strings.EqualFold("BadRequestException", errorCode): 938 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 939 940 case strings.EqualFold("ConflictException", errorCode): 941 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 942 943 case strings.EqualFold("ForbiddenException", errorCode): 944 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 945 946 case strings.EqualFold("InternalServerErrorException", errorCode): 947 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 948 949 case strings.EqualFold("NotFoundException", errorCode): 950 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 951 952 case strings.EqualFold("TooManyRequestsException", errorCode): 953 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 954 955 default: 956 genericError := &smithy.GenericAPIError{ 957 Code: errorCode, 958 Message: errorMessage, 959 } 960 return genericError 961 962 } 963} 964 965type awsRestjson1_deserializeOpDeletePreset struct { 966} 967 968func (*awsRestjson1_deserializeOpDeletePreset) ID() string { 969 return "OperationDeserializer" 970} 971 972func (m *awsRestjson1_deserializeOpDeletePreset) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 973 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 974) { 975 out, metadata, err = next.HandleDeserialize(ctx, in) 976 if err != nil { 977 return out, metadata, err 978 } 979 980 response, ok := out.RawResponse.(*smithyhttp.Response) 981 if !ok { 982 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 983 } 984 985 if response.StatusCode < 200 || response.StatusCode >= 300 { 986 return out, metadata, awsRestjson1_deserializeOpErrorDeletePreset(response, &metadata) 987 } 988 output := &DeletePresetOutput{} 989 out.Result = output 990 991 return out, metadata, err 992} 993 994func awsRestjson1_deserializeOpErrorDeletePreset(response *smithyhttp.Response, metadata *middleware.Metadata) error { 995 var errorBuffer bytes.Buffer 996 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 997 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 998 } 999 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1000 1001 errorCode := "UnknownError" 1002 errorMessage := errorCode 1003 1004 code := response.Header.Get("X-Amzn-ErrorType") 1005 if len(code) != 0 { 1006 errorCode = restjson.SanitizeErrorCode(code) 1007 } 1008 1009 var buff [1024]byte 1010 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1011 1012 body := io.TeeReader(errorBody, ringBuffer) 1013 decoder := json.NewDecoder(body) 1014 decoder.UseNumber() 1015 code, message, err := restjson.GetErrorInfo(decoder) 1016 if err != nil { 1017 var snapshot bytes.Buffer 1018 io.Copy(&snapshot, ringBuffer) 1019 err = &smithy.DeserializationError{ 1020 Err: fmt.Errorf("failed to decode response body, %w", err), 1021 Snapshot: snapshot.Bytes(), 1022 } 1023 return err 1024 } 1025 1026 errorBody.Seek(0, io.SeekStart) 1027 if len(code) != 0 { 1028 errorCode = restjson.SanitizeErrorCode(code) 1029 } 1030 if len(message) != 0 { 1031 errorMessage = message 1032 } 1033 1034 switch { 1035 case strings.EqualFold("BadRequestException", errorCode): 1036 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1037 1038 case strings.EqualFold("ConflictException", errorCode): 1039 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1040 1041 case strings.EqualFold("ForbiddenException", errorCode): 1042 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1043 1044 case strings.EqualFold("InternalServerErrorException", errorCode): 1045 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1046 1047 case strings.EqualFold("NotFoundException", errorCode): 1048 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1049 1050 case strings.EqualFold("TooManyRequestsException", errorCode): 1051 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1052 1053 default: 1054 genericError := &smithy.GenericAPIError{ 1055 Code: errorCode, 1056 Message: errorMessage, 1057 } 1058 return genericError 1059 1060 } 1061} 1062 1063type awsRestjson1_deserializeOpDeleteQueue struct { 1064} 1065 1066func (*awsRestjson1_deserializeOpDeleteQueue) ID() string { 1067 return "OperationDeserializer" 1068} 1069 1070func (m *awsRestjson1_deserializeOpDeleteQueue) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1071 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1072) { 1073 out, metadata, err = next.HandleDeserialize(ctx, in) 1074 if err != nil { 1075 return out, metadata, err 1076 } 1077 1078 response, ok := out.RawResponse.(*smithyhttp.Response) 1079 if !ok { 1080 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1081 } 1082 1083 if response.StatusCode < 200 || response.StatusCode >= 300 { 1084 return out, metadata, awsRestjson1_deserializeOpErrorDeleteQueue(response, &metadata) 1085 } 1086 output := &DeleteQueueOutput{} 1087 out.Result = output 1088 1089 return out, metadata, err 1090} 1091 1092func awsRestjson1_deserializeOpErrorDeleteQueue(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1093 var errorBuffer bytes.Buffer 1094 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1095 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1096 } 1097 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1098 1099 errorCode := "UnknownError" 1100 errorMessage := errorCode 1101 1102 code := response.Header.Get("X-Amzn-ErrorType") 1103 if len(code) != 0 { 1104 errorCode = restjson.SanitizeErrorCode(code) 1105 } 1106 1107 var buff [1024]byte 1108 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1109 1110 body := io.TeeReader(errorBody, ringBuffer) 1111 decoder := json.NewDecoder(body) 1112 decoder.UseNumber() 1113 code, message, err := restjson.GetErrorInfo(decoder) 1114 if err != nil { 1115 var snapshot bytes.Buffer 1116 io.Copy(&snapshot, ringBuffer) 1117 err = &smithy.DeserializationError{ 1118 Err: fmt.Errorf("failed to decode response body, %w", err), 1119 Snapshot: snapshot.Bytes(), 1120 } 1121 return err 1122 } 1123 1124 errorBody.Seek(0, io.SeekStart) 1125 if len(code) != 0 { 1126 errorCode = restjson.SanitizeErrorCode(code) 1127 } 1128 if len(message) != 0 { 1129 errorMessage = message 1130 } 1131 1132 switch { 1133 case strings.EqualFold("BadRequestException", errorCode): 1134 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1135 1136 case strings.EqualFold("ConflictException", errorCode): 1137 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1138 1139 case strings.EqualFold("ForbiddenException", errorCode): 1140 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1141 1142 case strings.EqualFold("InternalServerErrorException", errorCode): 1143 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1144 1145 case strings.EqualFold("NotFoundException", errorCode): 1146 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1147 1148 case strings.EqualFold("TooManyRequestsException", errorCode): 1149 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1150 1151 default: 1152 genericError := &smithy.GenericAPIError{ 1153 Code: errorCode, 1154 Message: errorMessage, 1155 } 1156 return genericError 1157 1158 } 1159} 1160 1161type awsRestjson1_deserializeOpDescribeEndpoints struct { 1162} 1163 1164func (*awsRestjson1_deserializeOpDescribeEndpoints) ID() string { 1165 return "OperationDeserializer" 1166} 1167 1168func (m *awsRestjson1_deserializeOpDescribeEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1169 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1170) { 1171 out, metadata, err = next.HandleDeserialize(ctx, in) 1172 if err != nil { 1173 return out, metadata, err 1174 } 1175 1176 response, ok := out.RawResponse.(*smithyhttp.Response) 1177 if !ok { 1178 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1179 } 1180 1181 if response.StatusCode < 200 || response.StatusCode >= 300 { 1182 return out, metadata, awsRestjson1_deserializeOpErrorDescribeEndpoints(response, &metadata) 1183 } 1184 output := &DescribeEndpointsOutput{} 1185 out.Result = output 1186 1187 var buff [1024]byte 1188 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1189 1190 body := io.TeeReader(response.Body, ringBuffer) 1191 1192 decoder := json.NewDecoder(body) 1193 decoder.UseNumber() 1194 var shape interface{} 1195 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1196 var snapshot bytes.Buffer 1197 io.Copy(&snapshot, ringBuffer) 1198 err = &smithy.DeserializationError{ 1199 Err: fmt.Errorf("failed to decode response body, %w", err), 1200 Snapshot: snapshot.Bytes(), 1201 } 1202 return out, metadata, err 1203 } 1204 1205 err = awsRestjson1_deserializeOpDocumentDescribeEndpointsOutput(&output, shape) 1206 if err != nil { 1207 var snapshot bytes.Buffer 1208 io.Copy(&snapshot, ringBuffer) 1209 return out, metadata, &smithy.DeserializationError{ 1210 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1211 Snapshot: snapshot.Bytes(), 1212 } 1213 } 1214 1215 return out, metadata, err 1216} 1217 1218func awsRestjson1_deserializeOpErrorDescribeEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1219 var errorBuffer bytes.Buffer 1220 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1221 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1222 } 1223 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1224 1225 errorCode := "UnknownError" 1226 errorMessage := errorCode 1227 1228 code := response.Header.Get("X-Amzn-ErrorType") 1229 if len(code) != 0 { 1230 errorCode = restjson.SanitizeErrorCode(code) 1231 } 1232 1233 var buff [1024]byte 1234 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1235 1236 body := io.TeeReader(errorBody, ringBuffer) 1237 decoder := json.NewDecoder(body) 1238 decoder.UseNumber() 1239 code, message, err := restjson.GetErrorInfo(decoder) 1240 if err != nil { 1241 var snapshot bytes.Buffer 1242 io.Copy(&snapshot, ringBuffer) 1243 err = &smithy.DeserializationError{ 1244 Err: fmt.Errorf("failed to decode response body, %w", err), 1245 Snapshot: snapshot.Bytes(), 1246 } 1247 return err 1248 } 1249 1250 errorBody.Seek(0, io.SeekStart) 1251 if len(code) != 0 { 1252 errorCode = restjson.SanitizeErrorCode(code) 1253 } 1254 if len(message) != 0 { 1255 errorMessage = message 1256 } 1257 1258 switch { 1259 case strings.EqualFold("BadRequestException", errorCode): 1260 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1261 1262 case strings.EqualFold("ConflictException", errorCode): 1263 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1264 1265 case strings.EqualFold("ForbiddenException", errorCode): 1266 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1267 1268 case strings.EqualFold("InternalServerErrorException", errorCode): 1269 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1270 1271 case strings.EqualFold("NotFoundException", errorCode): 1272 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1273 1274 case strings.EqualFold("TooManyRequestsException", errorCode): 1275 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1276 1277 default: 1278 genericError := &smithy.GenericAPIError{ 1279 Code: errorCode, 1280 Message: errorMessage, 1281 } 1282 return genericError 1283 1284 } 1285} 1286 1287func awsRestjson1_deserializeOpDocumentDescribeEndpointsOutput(v **DescribeEndpointsOutput, value interface{}) error { 1288 if v == nil { 1289 return fmt.Errorf("unexpected nil of type %T", v) 1290 } 1291 if value == nil { 1292 return nil 1293 } 1294 1295 shape, ok := value.(map[string]interface{}) 1296 if !ok { 1297 return fmt.Errorf("unexpected JSON type %v", value) 1298 } 1299 1300 var sv *DescribeEndpointsOutput 1301 if *v == nil { 1302 sv = &DescribeEndpointsOutput{} 1303 } else { 1304 sv = *v 1305 } 1306 1307 for key, value := range shape { 1308 switch key { 1309 case "endpoints": 1310 if err := awsRestjson1_deserializeDocument__listOfEndpoint(&sv.Endpoints, value); err != nil { 1311 return err 1312 } 1313 1314 case "nextToken": 1315 if value != nil { 1316 jtv, ok := value.(string) 1317 if !ok { 1318 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 1319 } 1320 sv.NextToken = ptr.String(jtv) 1321 } 1322 1323 default: 1324 _, _ = key, value 1325 1326 } 1327 } 1328 *v = sv 1329 return nil 1330} 1331 1332type awsRestjson1_deserializeOpDisassociateCertificate struct { 1333} 1334 1335func (*awsRestjson1_deserializeOpDisassociateCertificate) ID() string { 1336 return "OperationDeserializer" 1337} 1338 1339func (m *awsRestjson1_deserializeOpDisassociateCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1340 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1341) { 1342 out, metadata, err = next.HandleDeserialize(ctx, in) 1343 if err != nil { 1344 return out, metadata, err 1345 } 1346 1347 response, ok := out.RawResponse.(*smithyhttp.Response) 1348 if !ok { 1349 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1350 } 1351 1352 if response.StatusCode < 200 || response.StatusCode >= 300 { 1353 return out, metadata, awsRestjson1_deserializeOpErrorDisassociateCertificate(response, &metadata) 1354 } 1355 output := &DisassociateCertificateOutput{} 1356 out.Result = output 1357 1358 return out, metadata, err 1359} 1360 1361func awsRestjson1_deserializeOpErrorDisassociateCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1362 var errorBuffer bytes.Buffer 1363 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1364 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1365 } 1366 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1367 1368 errorCode := "UnknownError" 1369 errorMessage := errorCode 1370 1371 code := response.Header.Get("X-Amzn-ErrorType") 1372 if len(code) != 0 { 1373 errorCode = restjson.SanitizeErrorCode(code) 1374 } 1375 1376 var buff [1024]byte 1377 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1378 1379 body := io.TeeReader(errorBody, ringBuffer) 1380 decoder := json.NewDecoder(body) 1381 decoder.UseNumber() 1382 code, message, err := restjson.GetErrorInfo(decoder) 1383 if err != nil { 1384 var snapshot bytes.Buffer 1385 io.Copy(&snapshot, ringBuffer) 1386 err = &smithy.DeserializationError{ 1387 Err: fmt.Errorf("failed to decode response body, %w", err), 1388 Snapshot: snapshot.Bytes(), 1389 } 1390 return err 1391 } 1392 1393 errorBody.Seek(0, io.SeekStart) 1394 if len(code) != 0 { 1395 errorCode = restjson.SanitizeErrorCode(code) 1396 } 1397 if len(message) != 0 { 1398 errorMessage = message 1399 } 1400 1401 switch { 1402 case strings.EqualFold("BadRequestException", errorCode): 1403 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1404 1405 case strings.EqualFold("ConflictException", errorCode): 1406 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1407 1408 case strings.EqualFold("ForbiddenException", errorCode): 1409 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1410 1411 case strings.EqualFold("InternalServerErrorException", errorCode): 1412 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1413 1414 case strings.EqualFold("NotFoundException", errorCode): 1415 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1416 1417 case strings.EqualFold("TooManyRequestsException", errorCode): 1418 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1419 1420 default: 1421 genericError := &smithy.GenericAPIError{ 1422 Code: errorCode, 1423 Message: errorMessage, 1424 } 1425 return genericError 1426 1427 } 1428} 1429 1430type awsRestjson1_deserializeOpGetJob struct { 1431} 1432 1433func (*awsRestjson1_deserializeOpGetJob) ID() string { 1434 return "OperationDeserializer" 1435} 1436 1437func (m *awsRestjson1_deserializeOpGetJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1438 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1439) { 1440 out, metadata, err = next.HandleDeserialize(ctx, in) 1441 if err != nil { 1442 return out, metadata, err 1443 } 1444 1445 response, ok := out.RawResponse.(*smithyhttp.Response) 1446 if !ok { 1447 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1448 } 1449 1450 if response.StatusCode < 200 || response.StatusCode >= 300 { 1451 return out, metadata, awsRestjson1_deserializeOpErrorGetJob(response, &metadata) 1452 } 1453 output := &GetJobOutput{} 1454 out.Result = output 1455 1456 var buff [1024]byte 1457 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1458 1459 body := io.TeeReader(response.Body, ringBuffer) 1460 1461 decoder := json.NewDecoder(body) 1462 decoder.UseNumber() 1463 var shape interface{} 1464 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1465 var snapshot bytes.Buffer 1466 io.Copy(&snapshot, ringBuffer) 1467 err = &smithy.DeserializationError{ 1468 Err: fmt.Errorf("failed to decode response body, %w", err), 1469 Snapshot: snapshot.Bytes(), 1470 } 1471 return out, metadata, err 1472 } 1473 1474 err = awsRestjson1_deserializeOpDocumentGetJobOutput(&output, shape) 1475 if err != nil { 1476 var snapshot bytes.Buffer 1477 io.Copy(&snapshot, ringBuffer) 1478 return out, metadata, &smithy.DeserializationError{ 1479 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1480 Snapshot: snapshot.Bytes(), 1481 } 1482 } 1483 1484 return out, metadata, err 1485} 1486 1487func awsRestjson1_deserializeOpErrorGetJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1488 var errorBuffer bytes.Buffer 1489 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1490 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1491 } 1492 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1493 1494 errorCode := "UnknownError" 1495 errorMessage := errorCode 1496 1497 code := response.Header.Get("X-Amzn-ErrorType") 1498 if len(code) != 0 { 1499 errorCode = restjson.SanitizeErrorCode(code) 1500 } 1501 1502 var buff [1024]byte 1503 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1504 1505 body := io.TeeReader(errorBody, ringBuffer) 1506 decoder := json.NewDecoder(body) 1507 decoder.UseNumber() 1508 code, message, err := restjson.GetErrorInfo(decoder) 1509 if err != nil { 1510 var snapshot bytes.Buffer 1511 io.Copy(&snapshot, ringBuffer) 1512 err = &smithy.DeserializationError{ 1513 Err: fmt.Errorf("failed to decode response body, %w", err), 1514 Snapshot: snapshot.Bytes(), 1515 } 1516 return err 1517 } 1518 1519 errorBody.Seek(0, io.SeekStart) 1520 if len(code) != 0 { 1521 errorCode = restjson.SanitizeErrorCode(code) 1522 } 1523 if len(message) != 0 { 1524 errorMessage = message 1525 } 1526 1527 switch { 1528 case strings.EqualFold("BadRequestException", errorCode): 1529 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1530 1531 case strings.EqualFold("ConflictException", errorCode): 1532 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1533 1534 case strings.EqualFold("ForbiddenException", errorCode): 1535 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1536 1537 case strings.EqualFold("InternalServerErrorException", errorCode): 1538 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1539 1540 case strings.EqualFold("NotFoundException", errorCode): 1541 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1542 1543 case strings.EqualFold("TooManyRequestsException", errorCode): 1544 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1545 1546 default: 1547 genericError := &smithy.GenericAPIError{ 1548 Code: errorCode, 1549 Message: errorMessage, 1550 } 1551 return genericError 1552 1553 } 1554} 1555 1556func awsRestjson1_deserializeOpDocumentGetJobOutput(v **GetJobOutput, value interface{}) error { 1557 if v == nil { 1558 return fmt.Errorf("unexpected nil of type %T", v) 1559 } 1560 if value == nil { 1561 return nil 1562 } 1563 1564 shape, ok := value.(map[string]interface{}) 1565 if !ok { 1566 return fmt.Errorf("unexpected JSON type %v", value) 1567 } 1568 1569 var sv *GetJobOutput 1570 if *v == nil { 1571 sv = &GetJobOutput{} 1572 } else { 1573 sv = *v 1574 } 1575 1576 for key, value := range shape { 1577 switch key { 1578 case "job": 1579 if err := awsRestjson1_deserializeDocumentJob(&sv.Job, value); err != nil { 1580 return err 1581 } 1582 1583 default: 1584 _, _ = key, value 1585 1586 } 1587 } 1588 *v = sv 1589 return nil 1590} 1591 1592type awsRestjson1_deserializeOpGetJobTemplate struct { 1593} 1594 1595func (*awsRestjson1_deserializeOpGetJobTemplate) ID() string { 1596 return "OperationDeserializer" 1597} 1598 1599func (m *awsRestjson1_deserializeOpGetJobTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1600 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1601) { 1602 out, metadata, err = next.HandleDeserialize(ctx, in) 1603 if err != nil { 1604 return out, metadata, err 1605 } 1606 1607 response, ok := out.RawResponse.(*smithyhttp.Response) 1608 if !ok { 1609 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1610 } 1611 1612 if response.StatusCode < 200 || response.StatusCode >= 300 { 1613 return out, metadata, awsRestjson1_deserializeOpErrorGetJobTemplate(response, &metadata) 1614 } 1615 output := &GetJobTemplateOutput{} 1616 out.Result = output 1617 1618 var buff [1024]byte 1619 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1620 1621 body := io.TeeReader(response.Body, ringBuffer) 1622 1623 decoder := json.NewDecoder(body) 1624 decoder.UseNumber() 1625 var shape interface{} 1626 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1627 var snapshot bytes.Buffer 1628 io.Copy(&snapshot, ringBuffer) 1629 err = &smithy.DeserializationError{ 1630 Err: fmt.Errorf("failed to decode response body, %w", err), 1631 Snapshot: snapshot.Bytes(), 1632 } 1633 return out, metadata, err 1634 } 1635 1636 err = awsRestjson1_deserializeOpDocumentGetJobTemplateOutput(&output, shape) 1637 if err != nil { 1638 var snapshot bytes.Buffer 1639 io.Copy(&snapshot, ringBuffer) 1640 return out, metadata, &smithy.DeserializationError{ 1641 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1642 Snapshot: snapshot.Bytes(), 1643 } 1644 } 1645 1646 return out, metadata, err 1647} 1648 1649func awsRestjson1_deserializeOpErrorGetJobTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1650 var errorBuffer bytes.Buffer 1651 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1652 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1653 } 1654 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1655 1656 errorCode := "UnknownError" 1657 errorMessage := errorCode 1658 1659 code := response.Header.Get("X-Amzn-ErrorType") 1660 if len(code) != 0 { 1661 errorCode = restjson.SanitizeErrorCode(code) 1662 } 1663 1664 var buff [1024]byte 1665 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1666 1667 body := io.TeeReader(errorBody, ringBuffer) 1668 decoder := json.NewDecoder(body) 1669 decoder.UseNumber() 1670 code, message, err := restjson.GetErrorInfo(decoder) 1671 if err != nil { 1672 var snapshot bytes.Buffer 1673 io.Copy(&snapshot, ringBuffer) 1674 err = &smithy.DeserializationError{ 1675 Err: fmt.Errorf("failed to decode response body, %w", err), 1676 Snapshot: snapshot.Bytes(), 1677 } 1678 return err 1679 } 1680 1681 errorBody.Seek(0, io.SeekStart) 1682 if len(code) != 0 { 1683 errorCode = restjson.SanitizeErrorCode(code) 1684 } 1685 if len(message) != 0 { 1686 errorMessage = message 1687 } 1688 1689 switch { 1690 case strings.EqualFold("BadRequestException", errorCode): 1691 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1692 1693 case strings.EqualFold("ConflictException", errorCode): 1694 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1695 1696 case strings.EqualFold("ForbiddenException", errorCode): 1697 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1698 1699 case strings.EqualFold("InternalServerErrorException", errorCode): 1700 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1701 1702 case strings.EqualFold("NotFoundException", errorCode): 1703 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1704 1705 case strings.EqualFold("TooManyRequestsException", errorCode): 1706 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1707 1708 default: 1709 genericError := &smithy.GenericAPIError{ 1710 Code: errorCode, 1711 Message: errorMessage, 1712 } 1713 return genericError 1714 1715 } 1716} 1717 1718func awsRestjson1_deserializeOpDocumentGetJobTemplateOutput(v **GetJobTemplateOutput, value interface{}) error { 1719 if v == nil { 1720 return fmt.Errorf("unexpected nil of type %T", v) 1721 } 1722 if value == nil { 1723 return nil 1724 } 1725 1726 shape, ok := value.(map[string]interface{}) 1727 if !ok { 1728 return fmt.Errorf("unexpected JSON type %v", value) 1729 } 1730 1731 var sv *GetJobTemplateOutput 1732 if *v == nil { 1733 sv = &GetJobTemplateOutput{} 1734 } else { 1735 sv = *v 1736 } 1737 1738 for key, value := range shape { 1739 switch key { 1740 case "jobTemplate": 1741 if err := awsRestjson1_deserializeDocumentJobTemplate(&sv.JobTemplate, value); err != nil { 1742 return err 1743 } 1744 1745 default: 1746 _, _ = key, value 1747 1748 } 1749 } 1750 *v = sv 1751 return nil 1752} 1753 1754type awsRestjson1_deserializeOpGetPreset struct { 1755} 1756 1757func (*awsRestjson1_deserializeOpGetPreset) ID() string { 1758 return "OperationDeserializer" 1759} 1760 1761func (m *awsRestjson1_deserializeOpGetPreset) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1762 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1763) { 1764 out, metadata, err = next.HandleDeserialize(ctx, in) 1765 if err != nil { 1766 return out, metadata, err 1767 } 1768 1769 response, ok := out.RawResponse.(*smithyhttp.Response) 1770 if !ok { 1771 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1772 } 1773 1774 if response.StatusCode < 200 || response.StatusCode >= 300 { 1775 return out, metadata, awsRestjson1_deserializeOpErrorGetPreset(response, &metadata) 1776 } 1777 output := &GetPresetOutput{} 1778 out.Result = output 1779 1780 var buff [1024]byte 1781 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1782 1783 body := io.TeeReader(response.Body, ringBuffer) 1784 1785 decoder := json.NewDecoder(body) 1786 decoder.UseNumber() 1787 var shape interface{} 1788 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1789 var snapshot bytes.Buffer 1790 io.Copy(&snapshot, ringBuffer) 1791 err = &smithy.DeserializationError{ 1792 Err: fmt.Errorf("failed to decode response body, %w", err), 1793 Snapshot: snapshot.Bytes(), 1794 } 1795 return out, metadata, err 1796 } 1797 1798 err = awsRestjson1_deserializeOpDocumentGetPresetOutput(&output, shape) 1799 if err != nil { 1800 var snapshot bytes.Buffer 1801 io.Copy(&snapshot, ringBuffer) 1802 return out, metadata, &smithy.DeserializationError{ 1803 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1804 Snapshot: snapshot.Bytes(), 1805 } 1806 } 1807 1808 return out, metadata, err 1809} 1810 1811func awsRestjson1_deserializeOpErrorGetPreset(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1812 var errorBuffer bytes.Buffer 1813 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1814 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1815 } 1816 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1817 1818 errorCode := "UnknownError" 1819 errorMessage := errorCode 1820 1821 code := response.Header.Get("X-Amzn-ErrorType") 1822 if len(code) != 0 { 1823 errorCode = restjson.SanitizeErrorCode(code) 1824 } 1825 1826 var buff [1024]byte 1827 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1828 1829 body := io.TeeReader(errorBody, ringBuffer) 1830 decoder := json.NewDecoder(body) 1831 decoder.UseNumber() 1832 code, message, err := restjson.GetErrorInfo(decoder) 1833 if err != nil { 1834 var snapshot bytes.Buffer 1835 io.Copy(&snapshot, ringBuffer) 1836 err = &smithy.DeserializationError{ 1837 Err: fmt.Errorf("failed to decode response body, %w", err), 1838 Snapshot: snapshot.Bytes(), 1839 } 1840 return err 1841 } 1842 1843 errorBody.Seek(0, io.SeekStart) 1844 if len(code) != 0 { 1845 errorCode = restjson.SanitizeErrorCode(code) 1846 } 1847 if len(message) != 0 { 1848 errorMessage = message 1849 } 1850 1851 switch { 1852 case strings.EqualFold("BadRequestException", errorCode): 1853 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1854 1855 case strings.EqualFold("ConflictException", errorCode): 1856 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1857 1858 case strings.EqualFold("ForbiddenException", errorCode): 1859 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1860 1861 case strings.EqualFold("InternalServerErrorException", errorCode): 1862 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1863 1864 case strings.EqualFold("NotFoundException", errorCode): 1865 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1866 1867 case strings.EqualFold("TooManyRequestsException", errorCode): 1868 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1869 1870 default: 1871 genericError := &smithy.GenericAPIError{ 1872 Code: errorCode, 1873 Message: errorMessage, 1874 } 1875 return genericError 1876 1877 } 1878} 1879 1880func awsRestjson1_deserializeOpDocumentGetPresetOutput(v **GetPresetOutput, value interface{}) error { 1881 if v == nil { 1882 return fmt.Errorf("unexpected nil of type %T", v) 1883 } 1884 if value == nil { 1885 return nil 1886 } 1887 1888 shape, ok := value.(map[string]interface{}) 1889 if !ok { 1890 return fmt.Errorf("unexpected JSON type %v", value) 1891 } 1892 1893 var sv *GetPresetOutput 1894 if *v == nil { 1895 sv = &GetPresetOutput{} 1896 } else { 1897 sv = *v 1898 } 1899 1900 for key, value := range shape { 1901 switch key { 1902 case "preset": 1903 if err := awsRestjson1_deserializeDocumentPreset(&sv.Preset, value); err != nil { 1904 return err 1905 } 1906 1907 default: 1908 _, _ = key, value 1909 1910 } 1911 } 1912 *v = sv 1913 return nil 1914} 1915 1916type awsRestjson1_deserializeOpGetQueue struct { 1917} 1918 1919func (*awsRestjson1_deserializeOpGetQueue) ID() string { 1920 return "OperationDeserializer" 1921} 1922 1923func (m *awsRestjson1_deserializeOpGetQueue) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1924 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1925) { 1926 out, metadata, err = next.HandleDeserialize(ctx, in) 1927 if err != nil { 1928 return out, metadata, err 1929 } 1930 1931 response, ok := out.RawResponse.(*smithyhttp.Response) 1932 if !ok { 1933 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1934 } 1935 1936 if response.StatusCode < 200 || response.StatusCode >= 300 { 1937 return out, metadata, awsRestjson1_deserializeOpErrorGetQueue(response, &metadata) 1938 } 1939 output := &GetQueueOutput{} 1940 out.Result = output 1941 1942 var buff [1024]byte 1943 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1944 1945 body := io.TeeReader(response.Body, ringBuffer) 1946 1947 decoder := json.NewDecoder(body) 1948 decoder.UseNumber() 1949 var shape interface{} 1950 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1951 var snapshot bytes.Buffer 1952 io.Copy(&snapshot, ringBuffer) 1953 err = &smithy.DeserializationError{ 1954 Err: fmt.Errorf("failed to decode response body, %w", err), 1955 Snapshot: snapshot.Bytes(), 1956 } 1957 return out, metadata, err 1958 } 1959 1960 err = awsRestjson1_deserializeOpDocumentGetQueueOutput(&output, shape) 1961 if err != nil { 1962 var snapshot bytes.Buffer 1963 io.Copy(&snapshot, ringBuffer) 1964 return out, metadata, &smithy.DeserializationError{ 1965 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1966 Snapshot: snapshot.Bytes(), 1967 } 1968 } 1969 1970 return out, metadata, err 1971} 1972 1973func awsRestjson1_deserializeOpErrorGetQueue(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1974 var errorBuffer bytes.Buffer 1975 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1976 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1977 } 1978 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1979 1980 errorCode := "UnknownError" 1981 errorMessage := errorCode 1982 1983 code := response.Header.Get("X-Amzn-ErrorType") 1984 if len(code) != 0 { 1985 errorCode = restjson.SanitizeErrorCode(code) 1986 } 1987 1988 var buff [1024]byte 1989 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1990 1991 body := io.TeeReader(errorBody, ringBuffer) 1992 decoder := json.NewDecoder(body) 1993 decoder.UseNumber() 1994 code, message, err := restjson.GetErrorInfo(decoder) 1995 if err != nil { 1996 var snapshot bytes.Buffer 1997 io.Copy(&snapshot, ringBuffer) 1998 err = &smithy.DeserializationError{ 1999 Err: fmt.Errorf("failed to decode response body, %w", err), 2000 Snapshot: snapshot.Bytes(), 2001 } 2002 return err 2003 } 2004 2005 errorBody.Seek(0, io.SeekStart) 2006 if len(code) != 0 { 2007 errorCode = restjson.SanitizeErrorCode(code) 2008 } 2009 if len(message) != 0 { 2010 errorMessage = message 2011 } 2012 2013 switch { 2014 case strings.EqualFold("BadRequestException", errorCode): 2015 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2016 2017 case strings.EqualFold("ConflictException", errorCode): 2018 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2019 2020 case strings.EqualFold("ForbiddenException", errorCode): 2021 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 2022 2023 case strings.EqualFold("InternalServerErrorException", errorCode): 2024 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2025 2026 case strings.EqualFold("NotFoundException", errorCode): 2027 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 2028 2029 case strings.EqualFold("TooManyRequestsException", errorCode): 2030 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2031 2032 default: 2033 genericError := &smithy.GenericAPIError{ 2034 Code: errorCode, 2035 Message: errorMessage, 2036 } 2037 return genericError 2038 2039 } 2040} 2041 2042func awsRestjson1_deserializeOpDocumentGetQueueOutput(v **GetQueueOutput, value interface{}) error { 2043 if v == nil { 2044 return fmt.Errorf("unexpected nil of type %T", v) 2045 } 2046 if value == nil { 2047 return nil 2048 } 2049 2050 shape, ok := value.(map[string]interface{}) 2051 if !ok { 2052 return fmt.Errorf("unexpected JSON type %v", value) 2053 } 2054 2055 var sv *GetQueueOutput 2056 if *v == nil { 2057 sv = &GetQueueOutput{} 2058 } else { 2059 sv = *v 2060 } 2061 2062 for key, value := range shape { 2063 switch key { 2064 case "queue": 2065 if err := awsRestjson1_deserializeDocumentQueue(&sv.Queue, value); err != nil { 2066 return err 2067 } 2068 2069 default: 2070 _, _ = key, value 2071 2072 } 2073 } 2074 *v = sv 2075 return nil 2076} 2077 2078type awsRestjson1_deserializeOpListJobs struct { 2079} 2080 2081func (*awsRestjson1_deserializeOpListJobs) ID() string { 2082 return "OperationDeserializer" 2083} 2084 2085func (m *awsRestjson1_deserializeOpListJobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2086 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2087) { 2088 out, metadata, err = next.HandleDeserialize(ctx, in) 2089 if err != nil { 2090 return out, metadata, err 2091 } 2092 2093 response, ok := out.RawResponse.(*smithyhttp.Response) 2094 if !ok { 2095 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2096 } 2097 2098 if response.StatusCode < 200 || response.StatusCode >= 300 { 2099 return out, metadata, awsRestjson1_deserializeOpErrorListJobs(response, &metadata) 2100 } 2101 output := &ListJobsOutput{} 2102 out.Result = output 2103 2104 var buff [1024]byte 2105 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2106 2107 body := io.TeeReader(response.Body, ringBuffer) 2108 2109 decoder := json.NewDecoder(body) 2110 decoder.UseNumber() 2111 var shape interface{} 2112 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2113 var snapshot bytes.Buffer 2114 io.Copy(&snapshot, ringBuffer) 2115 err = &smithy.DeserializationError{ 2116 Err: fmt.Errorf("failed to decode response body, %w", err), 2117 Snapshot: snapshot.Bytes(), 2118 } 2119 return out, metadata, err 2120 } 2121 2122 err = awsRestjson1_deserializeOpDocumentListJobsOutput(&output, shape) 2123 if err != nil { 2124 var snapshot bytes.Buffer 2125 io.Copy(&snapshot, ringBuffer) 2126 return out, metadata, &smithy.DeserializationError{ 2127 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2128 Snapshot: snapshot.Bytes(), 2129 } 2130 } 2131 2132 return out, metadata, err 2133} 2134 2135func awsRestjson1_deserializeOpErrorListJobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2136 var errorBuffer bytes.Buffer 2137 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2138 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2139 } 2140 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2141 2142 errorCode := "UnknownError" 2143 errorMessage := errorCode 2144 2145 code := response.Header.Get("X-Amzn-ErrorType") 2146 if len(code) != 0 { 2147 errorCode = restjson.SanitizeErrorCode(code) 2148 } 2149 2150 var buff [1024]byte 2151 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2152 2153 body := io.TeeReader(errorBody, ringBuffer) 2154 decoder := json.NewDecoder(body) 2155 decoder.UseNumber() 2156 code, message, err := restjson.GetErrorInfo(decoder) 2157 if err != nil { 2158 var snapshot bytes.Buffer 2159 io.Copy(&snapshot, ringBuffer) 2160 err = &smithy.DeserializationError{ 2161 Err: fmt.Errorf("failed to decode response body, %w", err), 2162 Snapshot: snapshot.Bytes(), 2163 } 2164 return err 2165 } 2166 2167 errorBody.Seek(0, io.SeekStart) 2168 if len(code) != 0 { 2169 errorCode = restjson.SanitizeErrorCode(code) 2170 } 2171 if len(message) != 0 { 2172 errorMessage = message 2173 } 2174 2175 switch { 2176 case strings.EqualFold("BadRequestException", errorCode): 2177 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2178 2179 case strings.EqualFold("ConflictException", errorCode): 2180 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2181 2182 case strings.EqualFold("ForbiddenException", errorCode): 2183 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 2184 2185 case strings.EqualFold("InternalServerErrorException", errorCode): 2186 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2187 2188 case strings.EqualFold("NotFoundException", errorCode): 2189 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 2190 2191 case strings.EqualFold("TooManyRequestsException", errorCode): 2192 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2193 2194 default: 2195 genericError := &smithy.GenericAPIError{ 2196 Code: errorCode, 2197 Message: errorMessage, 2198 } 2199 return genericError 2200 2201 } 2202} 2203 2204func awsRestjson1_deserializeOpDocumentListJobsOutput(v **ListJobsOutput, value interface{}) error { 2205 if v == nil { 2206 return fmt.Errorf("unexpected nil of type %T", v) 2207 } 2208 if value == nil { 2209 return nil 2210 } 2211 2212 shape, ok := value.(map[string]interface{}) 2213 if !ok { 2214 return fmt.Errorf("unexpected JSON type %v", value) 2215 } 2216 2217 var sv *ListJobsOutput 2218 if *v == nil { 2219 sv = &ListJobsOutput{} 2220 } else { 2221 sv = *v 2222 } 2223 2224 for key, value := range shape { 2225 switch key { 2226 case "jobs": 2227 if err := awsRestjson1_deserializeDocument__listOfJob(&sv.Jobs, value); err != nil { 2228 return err 2229 } 2230 2231 case "nextToken": 2232 if value != nil { 2233 jtv, ok := value.(string) 2234 if !ok { 2235 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 2236 } 2237 sv.NextToken = ptr.String(jtv) 2238 } 2239 2240 default: 2241 _, _ = key, value 2242 2243 } 2244 } 2245 *v = sv 2246 return nil 2247} 2248 2249type awsRestjson1_deserializeOpListJobTemplates struct { 2250} 2251 2252func (*awsRestjson1_deserializeOpListJobTemplates) ID() string { 2253 return "OperationDeserializer" 2254} 2255 2256func (m *awsRestjson1_deserializeOpListJobTemplates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2257 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2258) { 2259 out, metadata, err = next.HandleDeserialize(ctx, in) 2260 if err != nil { 2261 return out, metadata, err 2262 } 2263 2264 response, ok := out.RawResponse.(*smithyhttp.Response) 2265 if !ok { 2266 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2267 } 2268 2269 if response.StatusCode < 200 || response.StatusCode >= 300 { 2270 return out, metadata, awsRestjson1_deserializeOpErrorListJobTemplates(response, &metadata) 2271 } 2272 output := &ListJobTemplatesOutput{} 2273 out.Result = output 2274 2275 var buff [1024]byte 2276 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2277 2278 body := io.TeeReader(response.Body, ringBuffer) 2279 2280 decoder := json.NewDecoder(body) 2281 decoder.UseNumber() 2282 var shape interface{} 2283 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2284 var snapshot bytes.Buffer 2285 io.Copy(&snapshot, ringBuffer) 2286 err = &smithy.DeserializationError{ 2287 Err: fmt.Errorf("failed to decode response body, %w", err), 2288 Snapshot: snapshot.Bytes(), 2289 } 2290 return out, metadata, err 2291 } 2292 2293 err = awsRestjson1_deserializeOpDocumentListJobTemplatesOutput(&output, shape) 2294 if err != nil { 2295 var snapshot bytes.Buffer 2296 io.Copy(&snapshot, ringBuffer) 2297 return out, metadata, &smithy.DeserializationError{ 2298 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2299 Snapshot: snapshot.Bytes(), 2300 } 2301 } 2302 2303 return out, metadata, err 2304} 2305 2306func awsRestjson1_deserializeOpErrorListJobTemplates(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2307 var errorBuffer bytes.Buffer 2308 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2309 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2310 } 2311 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2312 2313 errorCode := "UnknownError" 2314 errorMessage := errorCode 2315 2316 code := response.Header.Get("X-Amzn-ErrorType") 2317 if len(code) != 0 { 2318 errorCode = restjson.SanitizeErrorCode(code) 2319 } 2320 2321 var buff [1024]byte 2322 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2323 2324 body := io.TeeReader(errorBody, ringBuffer) 2325 decoder := json.NewDecoder(body) 2326 decoder.UseNumber() 2327 code, message, err := restjson.GetErrorInfo(decoder) 2328 if err != nil { 2329 var snapshot bytes.Buffer 2330 io.Copy(&snapshot, ringBuffer) 2331 err = &smithy.DeserializationError{ 2332 Err: fmt.Errorf("failed to decode response body, %w", err), 2333 Snapshot: snapshot.Bytes(), 2334 } 2335 return err 2336 } 2337 2338 errorBody.Seek(0, io.SeekStart) 2339 if len(code) != 0 { 2340 errorCode = restjson.SanitizeErrorCode(code) 2341 } 2342 if len(message) != 0 { 2343 errorMessage = message 2344 } 2345 2346 switch { 2347 case strings.EqualFold("BadRequestException", errorCode): 2348 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2349 2350 case strings.EqualFold("ConflictException", errorCode): 2351 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2352 2353 case strings.EqualFold("ForbiddenException", errorCode): 2354 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 2355 2356 case strings.EqualFold("InternalServerErrorException", errorCode): 2357 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2358 2359 case strings.EqualFold("NotFoundException", errorCode): 2360 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 2361 2362 case strings.EqualFold("TooManyRequestsException", errorCode): 2363 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2364 2365 default: 2366 genericError := &smithy.GenericAPIError{ 2367 Code: errorCode, 2368 Message: errorMessage, 2369 } 2370 return genericError 2371 2372 } 2373} 2374 2375func awsRestjson1_deserializeOpDocumentListJobTemplatesOutput(v **ListJobTemplatesOutput, value interface{}) error { 2376 if v == nil { 2377 return fmt.Errorf("unexpected nil of type %T", v) 2378 } 2379 if value == nil { 2380 return nil 2381 } 2382 2383 shape, ok := value.(map[string]interface{}) 2384 if !ok { 2385 return fmt.Errorf("unexpected JSON type %v", value) 2386 } 2387 2388 var sv *ListJobTemplatesOutput 2389 if *v == nil { 2390 sv = &ListJobTemplatesOutput{} 2391 } else { 2392 sv = *v 2393 } 2394 2395 for key, value := range shape { 2396 switch key { 2397 case "jobTemplates": 2398 if err := awsRestjson1_deserializeDocument__listOfJobTemplate(&sv.JobTemplates, value); err != nil { 2399 return err 2400 } 2401 2402 case "nextToken": 2403 if value != nil { 2404 jtv, ok := value.(string) 2405 if !ok { 2406 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 2407 } 2408 sv.NextToken = ptr.String(jtv) 2409 } 2410 2411 default: 2412 _, _ = key, value 2413 2414 } 2415 } 2416 *v = sv 2417 return nil 2418} 2419 2420type awsRestjson1_deserializeOpListPresets struct { 2421} 2422 2423func (*awsRestjson1_deserializeOpListPresets) ID() string { 2424 return "OperationDeserializer" 2425} 2426 2427func (m *awsRestjson1_deserializeOpListPresets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2428 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2429) { 2430 out, metadata, err = next.HandleDeserialize(ctx, in) 2431 if err != nil { 2432 return out, metadata, err 2433 } 2434 2435 response, ok := out.RawResponse.(*smithyhttp.Response) 2436 if !ok { 2437 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2438 } 2439 2440 if response.StatusCode < 200 || response.StatusCode >= 300 { 2441 return out, metadata, awsRestjson1_deserializeOpErrorListPresets(response, &metadata) 2442 } 2443 output := &ListPresetsOutput{} 2444 out.Result = output 2445 2446 var buff [1024]byte 2447 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2448 2449 body := io.TeeReader(response.Body, ringBuffer) 2450 2451 decoder := json.NewDecoder(body) 2452 decoder.UseNumber() 2453 var shape interface{} 2454 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2455 var snapshot bytes.Buffer 2456 io.Copy(&snapshot, ringBuffer) 2457 err = &smithy.DeserializationError{ 2458 Err: fmt.Errorf("failed to decode response body, %w", err), 2459 Snapshot: snapshot.Bytes(), 2460 } 2461 return out, metadata, err 2462 } 2463 2464 err = awsRestjson1_deserializeOpDocumentListPresetsOutput(&output, shape) 2465 if err != nil { 2466 var snapshot bytes.Buffer 2467 io.Copy(&snapshot, ringBuffer) 2468 return out, metadata, &smithy.DeserializationError{ 2469 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2470 Snapshot: snapshot.Bytes(), 2471 } 2472 } 2473 2474 return out, metadata, err 2475} 2476 2477func awsRestjson1_deserializeOpErrorListPresets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2478 var errorBuffer bytes.Buffer 2479 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2480 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2481 } 2482 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2483 2484 errorCode := "UnknownError" 2485 errorMessage := errorCode 2486 2487 code := response.Header.Get("X-Amzn-ErrorType") 2488 if len(code) != 0 { 2489 errorCode = restjson.SanitizeErrorCode(code) 2490 } 2491 2492 var buff [1024]byte 2493 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2494 2495 body := io.TeeReader(errorBody, ringBuffer) 2496 decoder := json.NewDecoder(body) 2497 decoder.UseNumber() 2498 code, message, err := restjson.GetErrorInfo(decoder) 2499 if err != nil { 2500 var snapshot bytes.Buffer 2501 io.Copy(&snapshot, ringBuffer) 2502 err = &smithy.DeserializationError{ 2503 Err: fmt.Errorf("failed to decode response body, %w", err), 2504 Snapshot: snapshot.Bytes(), 2505 } 2506 return err 2507 } 2508 2509 errorBody.Seek(0, io.SeekStart) 2510 if len(code) != 0 { 2511 errorCode = restjson.SanitizeErrorCode(code) 2512 } 2513 if len(message) != 0 { 2514 errorMessage = message 2515 } 2516 2517 switch { 2518 case strings.EqualFold("BadRequestException", errorCode): 2519 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2520 2521 case strings.EqualFold("ConflictException", errorCode): 2522 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2523 2524 case strings.EqualFold("ForbiddenException", errorCode): 2525 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 2526 2527 case strings.EqualFold("InternalServerErrorException", errorCode): 2528 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2529 2530 case strings.EqualFold("NotFoundException", errorCode): 2531 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 2532 2533 case strings.EqualFold("TooManyRequestsException", errorCode): 2534 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2535 2536 default: 2537 genericError := &smithy.GenericAPIError{ 2538 Code: errorCode, 2539 Message: errorMessage, 2540 } 2541 return genericError 2542 2543 } 2544} 2545 2546func awsRestjson1_deserializeOpDocumentListPresetsOutput(v **ListPresetsOutput, value interface{}) error { 2547 if v == nil { 2548 return fmt.Errorf("unexpected nil of type %T", v) 2549 } 2550 if value == nil { 2551 return nil 2552 } 2553 2554 shape, ok := value.(map[string]interface{}) 2555 if !ok { 2556 return fmt.Errorf("unexpected JSON type %v", value) 2557 } 2558 2559 var sv *ListPresetsOutput 2560 if *v == nil { 2561 sv = &ListPresetsOutput{} 2562 } else { 2563 sv = *v 2564 } 2565 2566 for key, value := range shape { 2567 switch key { 2568 case "nextToken": 2569 if value != nil { 2570 jtv, ok := value.(string) 2571 if !ok { 2572 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 2573 } 2574 sv.NextToken = ptr.String(jtv) 2575 } 2576 2577 case "presets": 2578 if err := awsRestjson1_deserializeDocument__listOfPreset(&sv.Presets, value); err != nil { 2579 return err 2580 } 2581 2582 default: 2583 _, _ = key, value 2584 2585 } 2586 } 2587 *v = sv 2588 return nil 2589} 2590 2591type awsRestjson1_deserializeOpListQueues struct { 2592} 2593 2594func (*awsRestjson1_deserializeOpListQueues) ID() string { 2595 return "OperationDeserializer" 2596} 2597 2598func (m *awsRestjson1_deserializeOpListQueues) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2599 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2600) { 2601 out, metadata, err = next.HandleDeserialize(ctx, in) 2602 if err != nil { 2603 return out, metadata, err 2604 } 2605 2606 response, ok := out.RawResponse.(*smithyhttp.Response) 2607 if !ok { 2608 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2609 } 2610 2611 if response.StatusCode < 200 || response.StatusCode >= 300 { 2612 return out, metadata, awsRestjson1_deserializeOpErrorListQueues(response, &metadata) 2613 } 2614 output := &ListQueuesOutput{} 2615 out.Result = output 2616 2617 var buff [1024]byte 2618 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2619 2620 body := io.TeeReader(response.Body, ringBuffer) 2621 2622 decoder := json.NewDecoder(body) 2623 decoder.UseNumber() 2624 var shape interface{} 2625 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2626 var snapshot bytes.Buffer 2627 io.Copy(&snapshot, ringBuffer) 2628 err = &smithy.DeserializationError{ 2629 Err: fmt.Errorf("failed to decode response body, %w", err), 2630 Snapshot: snapshot.Bytes(), 2631 } 2632 return out, metadata, err 2633 } 2634 2635 err = awsRestjson1_deserializeOpDocumentListQueuesOutput(&output, shape) 2636 if err != nil { 2637 var snapshot bytes.Buffer 2638 io.Copy(&snapshot, ringBuffer) 2639 return out, metadata, &smithy.DeserializationError{ 2640 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2641 Snapshot: snapshot.Bytes(), 2642 } 2643 } 2644 2645 return out, metadata, err 2646} 2647 2648func awsRestjson1_deserializeOpErrorListQueues(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2649 var errorBuffer bytes.Buffer 2650 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2651 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2652 } 2653 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2654 2655 errorCode := "UnknownError" 2656 errorMessage := errorCode 2657 2658 code := response.Header.Get("X-Amzn-ErrorType") 2659 if len(code) != 0 { 2660 errorCode = restjson.SanitizeErrorCode(code) 2661 } 2662 2663 var buff [1024]byte 2664 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2665 2666 body := io.TeeReader(errorBody, ringBuffer) 2667 decoder := json.NewDecoder(body) 2668 decoder.UseNumber() 2669 code, message, err := restjson.GetErrorInfo(decoder) 2670 if err != nil { 2671 var snapshot bytes.Buffer 2672 io.Copy(&snapshot, ringBuffer) 2673 err = &smithy.DeserializationError{ 2674 Err: fmt.Errorf("failed to decode response body, %w", err), 2675 Snapshot: snapshot.Bytes(), 2676 } 2677 return err 2678 } 2679 2680 errorBody.Seek(0, io.SeekStart) 2681 if len(code) != 0 { 2682 errorCode = restjson.SanitizeErrorCode(code) 2683 } 2684 if len(message) != 0 { 2685 errorMessage = message 2686 } 2687 2688 switch { 2689 case strings.EqualFold("BadRequestException", errorCode): 2690 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2691 2692 case strings.EqualFold("ConflictException", errorCode): 2693 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2694 2695 case strings.EqualFold("ForbiddenException", errorCode): 2696 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 2697 2698 case strings.EqualFold("InternalServerErrorException", errorCode): 2699 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2700 2701 case strings.EqualFold("NotFoundException", errorCode): 2702 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 2703 2704 case strings.EqualFold("TooManyRequestsException", errorCode): 2705 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2706 2707 default: 2708 genericError := &smithy.GenericAPIError{ 2709 Code: errorCode, 2710 Message: errorMessage, 2711 } 2712 return genericError 2713 2714 } 2715} 2716 2717func awsRestjson1_deserializeOpDocumentListQueuesOutput(v **ListQueuesOutput, value interface{}) error { 2718 if v == nil { 2719 return fmt.Errorf("unexpected nil of type %T", v) 2720 } 2721 if value == nil { 2722 return nil 2723 } 2724 2725 shape, ok := value.(map[string]interface{}) 2726 if !ok { 2727 return fmt.Errorf("unexpected JSON type %v", value) 2728 } 2729 2730 var sv *ListQueuesOutput 2731 if *v == nil { 2732 sv = &ListQueuesOutput{} 2733 } else { 2734 sv = *v 2735 } 2736 2737 for key, value := range shape { 2738 switch key { 2739 case "nextToken": 2740 if value != nil { 2741 jtv, ok := value.(string) 2742 if !ok { 2743 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 2744 } 2745 sv.NextToken = ptr.String(jtv) 2746 } 2747 2748 case "queues": 2749 if err := awsRestjson1_deserializeDocument__listOfQueue(&sv.Queues, value); err != nil { 2750 return err 2751 } 2752 2753 default: 2754 _, _ = key, value 2755 2756 } 2757 } 2758 *v = sv 2759 return nil 2760} 2761 2762type awsRestjson1_deserializeOpListTagsForResource struct { 2763} 2764 2765func (*awsRestjson1_deserializeOpListTagsForResource) ID() string { 2766 return "OperationDeserializer" 2767} 2768 2769func (m *awsRestjson1_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2770 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2771) { 2772 out, metadata, err = next.HandleDeserialize(ctx, in) 2773 if err != nil { 2774 return out, metadata, err 2775 } 2776 2777 response, ok := out.RawResponse.(*smithyhttp.Response) 2778 if !ok { 2779 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2780 } 2781 2782 if response.StatusCode < 200 || response.StatusCode >= 300 { 2783 return out, metadata, awsRestjson1_deserializeOpErrorListTagsForResource(response, &metadata) 2784 } 2785 output := &ListTagsForResourceOutput{} 2786 out.Result = output 2787 2788 var buff [1024]byte 2789 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2790 2791 body := io.TeeReader(response.Body, ringBuffer) 2792 2793 decoder := json.NewDecoder(body) 2794 decoder.UseNumber() 2795 var shape interface{} 2796 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2797 var snapshot bytes.Buffer 2798 io.Copy(&snapshot, ringBuffer) 2799 err = &smithy.DeserializationError{ 2800 Err: fmt.Errorf("failed to decode response body, %w", err), 2801 Snapshot: snapshot.Bytes(), 2802 } 2803 return out, metadata, err 2804 } 2805 2806 err = awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 2807 if err != nil { 2808 var snapshot bytes.Buffer 2809 io.Copy(&snapshot, ringBuffer) 2810 return out, metadata, &smithy.DeserializationError{ 2811 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2812 Snapshot: snapshot.Bytes(), 2813 } 2814 } 2815 2816 return out, metadata, err 2817} 2818 2819func awsRestjson1_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2820 var errorBuffer bytes.Buffer 2821 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2822 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2823 } 2824 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2825 2826 errorCode := "UnknownError" 2827 errorMessage := errorCode 2828 2829 code := response.Header.Get("X-Amzn-ErrorType") 2830 if len(code) != 0 { 2831 errorCode = restjson.SanitizeErrorCode(code) 2832 } 2833 2834 var buff [1024]byte 2835 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2836 2837 body := io.TeeReader(errorBody, ringBuffer) 2838 decoder := json.NewDecoder(body) 2839 decoder.UseNumber() 2840 code, message, err := restjson.GetErrorInfo(decoder) 2841 if err != nil { 2842 var snapshot bytes.Buffer 2843 io.Copy(&snapshot, ringBuffer) 2844 err = &smithy.DeserializationError{ 2845 Err: fmt.Errorf("failed to decode response body, %w", err), 2846 Snapshot: snapshot.Bytes(), 2847 } 2848 return err 2849 } 2850 2851 errorBody.Seek(0, io.SeekStart) 2852 if len(code) != 0 { 2853 errorCode = restjson.SanitizeErrorCode(code) 2854 } 2855 if len(message) != 0 { 2856 errorMessage = message 2857 } 2858 2859 switch { 2860 case strings.EqualFold("BadRequestException", errorCode): 2861 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2862 2863 case strings.EqualFold("ConflictException", errorCode): 2864 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2865 2866 case strings.EqualFold("ForbiddenException", errorCode): 2867 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 2868 2869 case strings.EqualFold("InternalServerErrorException", errorCode): 2870 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2871 2872 case strings.EqualFold("NotFoundException", errorCode): 2873 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 2874 2875 case strings.EqualFold("TooManyRequestsException", errorCode): 2876 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2877 2878 default: 2879 genericError := &smithy.GenericAPIError{ 2880 Code: errorCode, 2881 Message: errorMessage, 2882 } 2883 return genericError 2884 2885 } 2886} 2887 2888func awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 2889 if v == nil { 2890 return fmt.Errorf("unexpected nil of type %T", v) 2891 } 2892 if value == nil { 2893 return nil 2894 } 2895 2896 shape, ok := value.(map[string]interface{}) 2897 if !ok { 2898 return fmt.Errorf("unexpected JSON type %v", value) 2899 } 2900 2901 var sv *ListTagsForResourceOutput 2902 if *v == nil { 2903 sv = &ListTagsForResourceOutput{} 2904 } else { 2905 sv = *v 2906 } 2907 2908 for key, value := range shape { 2909 switch key { 2910 case "resourceTags": 2911 if err := awsRestjson1_deserializeDocumentResourceTags(&sv.ResourceTags, value); err != nil { 2912 return err 2913 } 2914 2915 default: 2916 _, _ = key, value 2917 2918 } 2919 } 2920 *v = sv 2921 return nil 2922} 2923 2924type awsRestjson1_deserializeOpTagResource struct { 2925} 2926 2927func (*awsRestjson1_deserializeOpTagResource) ID() string { 2928 return "OperationDeserializer" 2929} 2930 2931func (m *awsRestjson1_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2932 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2933) { 2934 out, metadata, err = next.HandleDeserialize(ctx, in) 2935 if err != nil { 2936 return out, metadata, err 2937 } 2938 2939 response, ok := out.RawResponse.(*smithyhttp.Response) 2940 if !ok { 2941 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2942 } 2943 2944 if response.StatusCode < 200 || response.StatusCode >= 300 { 2945 return out, metadata, awsRestjson1_deserializeOpErrorTagResource(response, &metadata) 2946 } 2947 output := &TagResourceOutput{} 2948 out.Result = output 2949 2950 return out, metadata, err 2951} 2952 2953func awsRestjson1_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2954 var errorBuffer bytes.Buffer 2955 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2956 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2957 } 2958 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2959 2960 errorCode := "UnknownError" 2961 errorMessage := errorCode 2962 2963 code := response.Header.Get("X-Amzn-ErrorType") 2964 if len(code) != 0 { 2965 errorCode = restjson.SanitizeErrorCode(code) 2966 } 2967 2968 var buff [1024]byte 2969 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2970 2971 body := io.TeeReader(errorBody, ringBuffer) 2972 decoder := json.NewDecoder(body) 2973 decoder.UseNumber() 2974 code, message, err := restjson.GetErrorInfo(decoder) 2975 if err != nil { 2976 var snapshot bytes.Buffer 2977 io.Copy(&snapshot, ringBuffer) 2978 err = &smithy.DeserializationError{ 2979 Err: fmt.Errorf("failed to decode response body, %w", err), 2980 Snapshot: snapshot.Bytes(), 2981 } 2982 return err 2983 } 2984 2985 errorBody.Seek(0, io.SeekStart) 2986 if len(code) != 0 { 2987 errorCode = restjson.SanitizeErrorCode(code) 2988 } 2989 if len(message) != 0 { 2990 errorMessage = message 2991 } 2992 2993 switch { 2994 case strings.EqualFold("BadRequestException", errorCode): 2995 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2996 2997 case strings.EqualFold("ConflictException", errorCode): 2998 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2999 3000 case strings.EqualFold("ForbiddenException", errorCode): 3001 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 3002 3003 case strings.EqualFold("InternalServerErrorException", errorCode): 3004 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3005 3006 case strings.EqualFold("NotFoundException", errorCode): 3007 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 3008 3009 case strings.EqualFold("TooManyRequestsException", errorCode): 3010 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3011 3012 default: 3013 genericError := &smithy.GenericAPIError{ 3014 Code: errorCode, 3015 Message: errorMessage, 3016 } 3017 return genericError 3018 3019 } 3020} 3021 3022type awsRestjson1_deserializeOpUntagResource struct { 3023} 3024 3025func (*awsRestjson1_deserializeOpUntagResource) ID() string { 3026 return "OperationDeserializer" 3027} 3028 3029func (m *awsRestjson1_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3030 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3031) { 3032 out, metadata, err = next.HandleDeserialize(ctx, in) 3033 if err != nil { 3034 return out, metadata, err 3035 } 3036 3037 response, ok := out.RawResponse.(*smithyhttp.Response) 3038 if !ok { 3039 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3040 } 3041 3042 if response.StatusCode < 200 || response.StatusCode >= 300 { 3043 return out, metadata, awsRestjson1_deserializeOpErrorUntagResource(response, &metadata) 3044 } 3045 output := &UntagResourceOutput{} 3046 out.Result = output 3047 3048 return out, metadata, err 3049} 3050 3051func awsRestjson1_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3052 var errorBuffer bytes.Buffer 3053 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3054 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3055 } 3056 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3057 3058 errorCode := "UnknownError" 3059 errorMessage := errorCode 3060 3061 code := response.Header.Get("X-Amzn-ErrorType") 3062 if len(code) != 0 { 3063 errorCode = restjson.SanitizeErrorCode(code) 3064 } 3065 3066 var buff [1024]byte 3067 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3068 3069 body := io.TeeReader(errorBody, ringBuffer) 3070 decoder := json.NewDecoder(body) 3071 decoder.UseNumber() 3072 code, message, err := restjson.GetErrorInfo(decoder) 3073 if err != nil { 3074 var snapshot bytes.Buffer 3075 io.Copy(&snapshot, ringBuffer) 3076 err = &smithy.DeserializationError{ 3077 Err: fmt.Errorf("failed to decode response body, %w", err), 3078 Snapshot: snapshot.Bytes(), 3079 } 3080 return err 3081 } 3082 3083 errorBody.Seek(0, io.SeekStart) 3084 if len(code) != 0 { 3085 errorCode = restjson.SanitizeErrorCode(code) 3086 } 3087 if len(message) != 0 { 3088 errorMessage = message 3089 } 3090 3091 switch { 3092 case strings.EqualFold("BadRequestException", errorCode): 3093 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3094 3095 case strings.EqualFold("ConflictException", errorCode): 3096 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3097 3098 case strings.EqualFold("ForbiddenException", errorCode): 3099 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 3100 3101 case strings.EqualFold("InternalServerErrorException", errorCode): 3102 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3103 3104 case strings.EqualFold("NotFoundException", errorCode): 3105 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 3106 3107 case strings.EqualFold("TooManyRequestsException", errorCode): 3108 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3109 3110 default: 3111 genericError := &smithy.GenericAPIError{ 3112 Code: errorCode, 3113 Message: errorMessage, 3114 } 3115 return genericError 3116 3117 } 3118} 3119 3120type awsRestjson1_deserializeOpUpdateJobTemplate struct { 3121} 3122 3123func (*awsRestjson1_deserializeOpUpdateJobTemplate) ID() string { 3124 return "OperationDeserializer" 3125} 3126 3127func (m *awsRestjson1_deserializeOpUpdateJobTemplate) 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, awsRestjson1_deserializeOpErrorUpdateJobTemplate(response, &metadata) 3142 } 3143 output := &UpdateJobTemplateOutput{} 3144 out.Result = output 3145 3146 var buff [1024]byte 3147 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3148 3149 body := io.TeeReader(response.Body, ringBuffer) 3150 3151 decoder := json.NewDecoder(body) 3152 decoder.UseNumber() 3153 var shape interface{} 3154 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3155 var snapshot bytes.Buffer 3156 io.Copy(&snapshot, ringBuffer) 3157 err = &smithy.DeserializationError{ 3158 Err: fmt.Errorf("failed to decode response body, %w", err), 3159 Snapshot: snapshot.Bytes(), 3160 } 3161 return out, metadata, err 3162 } 3163 3164 err = awsRestjson1_deserializeOpDocumentUpdateJobTemplateOutput(&output, shape) 3165 if err != nil { 3166 var snapshot bytes.Buffer 3167 io.Copy(&snapshot, ringBuffer) 3168 return out, metadata, &smithy.DeserializationError{ 3169 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3170 Snapshot: snapshot.Bytes(), 3171 } 3172 } 3173 3174 return out, metadata, err 3175} 3176 3177func awsRestjson1_deserializeOpErrorUpdateJobTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3178 var errorBuffer bytes.Buffer 3179 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3180 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3181 } 3182 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3183 3184 errorCode := "UnknownError" 3185 errorMessage := errorCode 3186 3187 code := response.Header.Get("X-Amzn-ErrorType") 3188 if len(code) != 0 { 3189 errorCode = restjson.SanitizeErrorCode(code) 3190 } 3191 3192 var buff [1024]byte 3193 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3194 3195 body := io.TeeReader(errorBody, ringBuffer) 3196 decoder := json.NewDecoder(body) 3197 decoder.UseNumber() 3198 code, message, err := restjson.GetErrorInfo(decoder) 3199 if err != nil { 3200 var snapshot bytes.Buffer 3201 io.Copy(&snapshot, ringBuffer) 3202 err = &smithy.DeserializationError{ 3203 Err: fmt.Errorf("failed to decode response body, %w", err), 3204 Snapshot: snapshot.Bytes(), 3205 } 3206 return err 3207 } 3208 3209 errorBody.Seek(0, io.SeekStart) 3210 if len(code) != 0 { 3211 errorCode = restjson.SanitizeErrorCode(code) 3212 } 3213 if len(message) != 0 { 3214 errorMessage = message 3215 } 3216 3217 switch { 3218 case strings.EqualFold("BadRequestException", errorCode): 3219 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3220 3221 case strings.EqualFold("ConflictException", errorCode): 3222 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3223 3224 case strings.EqualFold("ForbiddenException", errorCode): 3225 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 3226 3227 case strings.EqualFold("InternalServerErrorException", errorCode): 3228 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3229 3230 case strings.EqualFold("NotFoundException", errorCode): 3231 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 3232 3233 case strings.EqualFold("TooManyRequestsException", errorCode): 3234 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3235 3236 default: 3237 genericError := &smithy.GenericAPIError{ 3238 Code: errorCode, 3239 Message: errorMessage, 3240 } 3241 return genericError 3242 3243 } 3244} 3245 3246func awsRestjson1_deserializeOpDocumentUpdateJobTemplateOutput(v **UpdateJobTemplateOutput, value interface{}) error { 3247 if v == nil { 3248 return fmt.Errorf("unexpected nil of type %T", v) 3249 } 3250 if value == nil { 3251 return nil 3252 } 3253 3254 shape, ok := value.(map[string]interface{}) 3255 if !ok { 3256 return fmt.Errorf("unexpected JSON type %v", value) 3257 } 3258 3259 var sv *UpdateJobTemplateOutput 3260 if *v == nil { 3261 sv = &UpdateJobTemplateOutput{} 3262 } else { 3263 sv = *v 3264 } 3265 3266 for key, value := range shape { 3267 switch key { 3268 case "jobTemplate": 3269 if err := awsRestjson1_deserializeDocumentJobTemplate(&sv.JobTemplate, value); err != nil { 3270 return err 3271 } 3272 3273 default: 3274 _, _ = key, value 3275 3276 } 3277 } 3278 *v = sv 3279 return nil 3280} 3281 3282type awsRestjson1_deserializeOpUpdatePreset struct { 3283} 3284 3285func (*awsRestjson1_deserializeOpUpdatePreset) ID() string { 3286 return "OperationDeserializer" 3287} 3288 3289func (m *awsRestjson1_deserializeOpUpdatePreset) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3290 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3291) { 3292 out, metadata, err = next.HandleDeserialize(ctx, in) 3293 if err != nil { 3294 return out, metadata, err 3295 } 3296 3297 response, ok := out.RawResponse.(*smithyhttp.Response) 3298 if !ok { 3299 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3300 } 3301 3302 if response.StatusCode < 200 || response.StatusCode >= 300 { 3303 return out, metadata, awsRestjson1_deserializeOpErrorUpdatePreset(response, &metadata) 3304 } 3305 output := &UpdatePresetOutput{} 3306 out.Result = output 3307 3308 var buff [1024]byte 3309 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3310 3311 body := io.TeeReader(response.Body, ringBuffer) 3312 3313 decoder := json.NewDecoder(body) 3314 decoder.UseNumber() 3315 var shape interface{} 3316 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3317 var snapshot bytes.Buffer 3318 io.Copy(&snapshot, ringBuffer) 3319 err = &smithy.DeserializationError{ 3320 Err: fmt.Errorf("failed to decode response body, %w", err), 3321 Snapshot: snapshot.Bytes(), 3322 } 3323 return out, metadata, err 3324 } 3325 3326 err = awsRestjson1_deserializeOpDocumentUpdatePresetOutput(&output, shape) 3327 if err != nil { 3328 var snapshot bytes.Buffer 3329 io.Copy(&snapshot, ringBuffer) 3330 return out, metadata, &smithy.DeserializationError{ 3331 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3332 Snapshot: snapshot.Bytes(), 3333 } 3334 } 3335 3336 return out, metadata, err 3337} 3338 3339func awsRestjson1_deserializeOpErrorUpdatePreset(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3340 var errorBuffer bytes.Buffer 3341 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3342 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3343 } 3344 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3345 3346 errorCode := "UnknownError" 3347 errorMessage := errorCode 3348 3349 code := response.Header.Get("X-Amzn-ErrorType") 3350 if len(code) != 0 { 3351 errorCode = restjson.SanitizeErrorCode(code) 3352 } 3353 3354 var buff [1024]byte 3355 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3356 3357 body := io.TeeReader(errorBody, ringBuffer) 3358 decoder := json.NewDecoder(body) 3359 decoder.UseNumber() 3360 code, message, err := restjson.GetErrorInfo(decoder) 3361 if err != nil { 3362 var snapshot bytes.Buffer 3363 io.Copy(&snapshot, ringBuffer) 3364 err = &smithy.DeserializationError{ 3365 Err: fmt.Errorf("failed to decode response body, %w", err), 3366 Snapshot: snapshot.Bytes(), 3367 } 3368 return err 3369 } 3370 3371 errorBody.Seek(0, io.SeekStart) 3372 if len(code) != 0 { 3373 errorCode = restjson.SanitizeErrorCode(code) 3374 } 3375 if len(message) != 0 { 3376 errorMessage = message 3377 } 3378 3379 switch { 3380 case strings.EqualFold("BadRequestException", errorCode): 3381 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3382 3383 case strings.EqualFold("ConflictException", errorCode): 3384 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3385 3386 case strings.EqualFold("ForbiddenException", errorCode): 3387 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 3388 3389 case strings.EqualFold("InternalServerErrorException", errorCode): 3390 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3391 3392 case strings.EqualFold("NotFoundException", errorCode): 3393 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 3394 3395 case strings.EqualFold("TooManyRequestsException", errorCode): 3396 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3397 3398 default: 3399 genericError := &smithy.GenericAPIError{ 3400 Code: errorCode, 3401 Message: errorMessage, 3402 } 3403 return genericError 3404 3405 } 3406} 3407 3408func awsRestjson1_deserializeOpDocumentUpdatePresetOutput(v **UpdatePresetOutput, value interface{}) error { 3409 if v == nil { 3410 return fmt.Errorf("unexpected nil of type %T", v) 3411 } 3412 if value == nil { 3413 return nil 3414 } 3415 3416 shape, ok := value.(map[string]interface{}) 3417 if !ok { 3418 return fmt.Errorf("unexpected JSON type %v", value) 3419 } 3420 3421 var sv *UpdatePresetOutput 3422 if *v == nil { 3423 sv = &UpdatePresetOutput{} 3424 } else { 3425 sv = *v 3426 } 3427 3428 for key, value := range shape { 3429 switch key { 3430 case "preset": 3431 if err := awsRestjson1_deserializeDocumentPreset(&sv.Preset, value); err != nil { 3432 return err 3433 } 3434 3435 default: 3436 _, _ = key, value 3437 3438 } 3439 } 3440 *v = sv 3441 return nil 3442} 3443 3444type awsRestjson1_deserializeOpUpdateQueue struct { 3445} 3446 3447func (*awsRestjson1_deserializeOpUpdateQueue) ID() string { 3448 return "OperationDeserializer" 3449} 3450 3451func (m *awsRestjson1_deserializeOpUpdateQueue) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3452 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3453) { 3454 out, metadata, err = next.HandleDeserialize(ctx, in) 3455 if err != nil { 3456 return out, metadata, err 3457 } 3458 3459 response, ok := out.RawResponse.(*smithyhttp.Response) 3460 if !ok { 3461 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3462 } 3463 3464 if response.StatusCode < 200 || response.StatusCode >= 300 { 3465 return out, metadata, awsRestjson1_deserializeOpErrorUpdateQueue(response, &metadata) 3466 } 3467 output := &UpdateQueueOutput{} 3468 out.Result = output 3469 3470 var buff [1024]byte 3471 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3472 3473 body := io.TeeReader(response.Body, ringBuffer) 3474 3475 decoder := json.NewDecoder(body) 3476 decoder.UseNumber() 3477 var shape interface{} 3478 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3479 var snapshot bytes.Buffer 3480 io.Copy(&snapshot, ringBuffer) 3481 err = &smithy.DeserializationError{ 3482 Err: fmt.Errorf("failed to decode response body, %w", err), 3483 Snapshot: snapshot.Bytes(), 3484 } 3485 return out, metadata, err 3486 } 3487 3488 err = awsRestjson1_deserializeOpDocumentUpdateQueueOutput(&output, shape) 3489 if err != nil { 3490 var snapshot bytes.Buffer 3491 io.Copy(&snapshot, ringBuffer) 3492 return out, metadata, &smithy.DeserializationError{ 3493 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3494 Snapshot: snapshot.Bytes(), 3495 } 3496 } 3497 3498 return out, metadata, err 3499} 3500 3501func awsRestjson1_deserializeOpErrorUpdateQueue(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3502 var errorBuffer bytes.Buffer 3503 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3504 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3505 } 3506 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3507 3508 errorCode := "UnknownError" 3509 errorMessage := errorCode 3510 3511 code := response.Header.Get("X-Amzn-ErrorType") 3512 if len(code) != 0 { 3513 errorCode = restjson.SanitizeErrorCode(code) 3514 } 3515 3516 var buff [1024]byte 3517 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3518 3519 body := io.TeeReader(errorBody, ringBuffer) 3520 decoder := json.NewDecoder(body) 3521 decoder.UseNumber() 3522 code, message, err := restjson.GetErrorInfo(decoder) 3523 if err != nil { 3524 var snapshot bytes.Buffer 3525 io.Copy(&snapshot, ringBuffer) 3526 err = &smithy.DeserializationError{ 3527 Err: fmt.Errorf("failed to decode response body, %w", err), 3528 Snapshot: snapshot.Bytes(), 3529 } 3530 return err 3531 } 3532 3533 errorBody.Seek(0, io.SeekStart) 3534 if len(code) != 0 { 3535 errorCode = restjson.SanitizeErrorCode(code) 3536 } 3537 if len(message) != 0 { 3538 errorMessage = message 3539 } 3540 3541 switch { 3542 case strings.EqualFold("BadRequestException", errorCode): 3543 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3544 3545 case strings.EqualFold("ConflictException", errorCode): 3546 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3547 3548 case strings.EqualFold("ForbiddenException", errorCode): 3549 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 3550 3551 case strings.EqualFold("InternalServerErrorException", errorCode): 3552 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3553 3554 case strings.EqualFold("NotFoundException", errorCode): 3555 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 3556 3557 case strings.EqualFold("TooManyRequestsException", errorCode): 3558 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3559 3560 default: 3561 genericError := &smithy.GenericAPIError{ 3562 Code: errorCode, 3563 Message: errorMessage, 3564 } 3565 return genericError 3566 3567 } 3568} 3569 3570func awsRestjson1_deserializeOpDocumentUpdateQueueOutput(v **UpdateQueueOutput, value interface{}) error { 3571 if v == nil { 3572 return fmt.Errorf("unexpected nil of type %T", v) 3573 } 3574 if value == nil { 3575 return nil 3576 } 3577 3578 shape, ok := value.(map[string]interface{}) 3579 if !ok { 3580 return fmt.Errorf("unexpected JSON type %v", value) 3581 } 3582 3583 var sv *UpdateQueueOutput 3584 if *v == nil { 3585 sv = &UpdateQueueOutput{} 3586 } else { 3587 sv = *v 3588 } 3589 3590 for key, value := range shape { 3591 switch key { 3592 case "queue": 3593 if err := awsRestjson1_deserializeDocumentQueue(&sv.Queue, value); err != nil { 3594 return err 3595 } 3596 3597 default: 3598 _, _ = key, value 3599 3600 } 3601 } 3602 *v = sv 3603 return nil 3604} 3605 3606func awsRestjson1_deserializeErrorBadRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3607 output := &types.BadRequestException{} 3608 var buff [1024]byte 3609 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3610 3611 body := io.TeeReader(errorBody, ringBuffer) 3612 decoder := json.NewDecoder(body) 3613 decoder.UseNumber() 3614 var shape interface{} 3615 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3616 var snapshot bytes.Buffer 3617 io.Copy(&snapshot, ringBuffer) 3618 err = &smithy.DeserializationError{ 3619 Err: fmt.Errorf("failed to decode response body, %w", err), 3620 Snapshot: snapshot.Bytes(), 3621 } 3622 return err 3623 } 3624 3625 err := awsRestjson1_deserializeDocumentBadRequestException(&output, shape) 3626 3627 if err != nil { 3628 var snapshot bytes.Buffer 3629 io.Copy(&snapshot, ringBuffer) 3630 err = &smithy.DeserializationError{ 3631 Err: fmt.Errorf("failed to decode response body, %w", err), 3632 Snapshot: snapshot.Bytes(), 3633 } 3634 return err 3635 } 3636 3637 errorBody.Seek(0, io.SeekStart) 3638 3639 return output 3640} 3641 3642func awsRestjson1_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3643 output := &types.ConflictException{} 3644 var buff [1024]byte 3645 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3646 3647 body := io.TeeReader(errorBody, ringBuffer) 3648 decoder := json.NewDecoder(body) 3649 decoder.UseNumber() 3650 var shape interface{} 3651 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3652 var snapshot bytes.Buffer 3653 io.Copy(&snapshot, ringBuffer) 3654 err = &smithy.DeserializationError{ 3655 Err: fmt.Errorf("failed to decode response body, %w", err), 3656 Snapshot: snapshot.Bytes(), 3657 } 3658 return err 3659 } 3660 3661 err := awsRestjson1_deserializeDocumentConflictException(&output, shape) 3662 3663 if err != nil { 3664 var snapshot bytes.Buffer 3665 io.Copy(&snapshot, ringBuffer) 3666 err = &smithy.DeserializationError{ 3667 Err: fmt.Errorf("failed to decode response body, %w", err), 3668 Snapshot: snapshot.Bytes(), 3669 } 3670 return err 3671 } 3672 3673 errorBody.Seek(0, io.SeekStart) 3674 3675 return output 3676} 3677 3678func awsRestjson1_deserializeErrorForbiddenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3679 output := &types.ForbiddenException{} 3680 var buff [1024]byte 3681 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3682 3683 body := io.TeeReader(errorBody, ringBuffer) 3684 decoder := json.NewDecoder(body) 3685 decoder.UseNumber() 3686 var shape interface{} 3687 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3688 var snapshot bytes.Buffer 3689 io.Copy(&snapshot, ringBuffer) 3690 err = &smithy.DeserializationError{ 3691 Err: fmt.Errorf("failed to decode response body, %w", err), 3692 Snapshot: snapshot.Bytes(), 3693 } 3694 return err 3695 } 3696 3697 err := awsRestjson1_deserializeDocumentForbiddenException(&output, shape) 3698 3699 if err != nil { 3700 var snapshot bytes.Buffer 3701 io.Copy(&snapshot, ringBuffer) 3702 err = &smithy.DeserializationError{ 3703 Err: fmt.Errorf("failed to decode response body, %w", err), 3704 Snapshot: snapshot.Bytes(), 3705 } 3706 return err 3707 } 3708 3709 errorBody.Seek(0, io.SeekStart) 3710 3711 return output 3712} 3713 3714func awsRestjson1_deserializeErrorInternalServerErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3715 output := &types.InternalServerErrorException{} 3716 var buff [1024]byte 3717 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3718 3719 body := io.TeeReader(errorBody, ringBuffer) 3720 decoder := json.NewDecoder(body) 3721 decoder.UseNumber() 3722 var shape interface{} 3723 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3724 var snapshot bytes.Buffer 3725 io.Copy(&snapshot, ringBuffer) 3726 err = &smithy.DeserializationError{ 3727 Err: fmt.Errorf("failed to decode response body, %w", err), 3728 Snapshot: snapshot.Bytes(), 3729 } 3730 return err 3731 } 3732 3733 err := awsRestjson1_deserializeDocumentInternalServerErrorException(&output, shape) 3734 3735 if err != nil { 3736 var snapshot bytes.Buffer 3737 io.Copy(&snapshot, ringBuffer) 3738 err = &smithy.DeserializationError{ 3739 Err: fmt.Errorf("failed to decode response body, %w", err), 3740 Snapshot: snapshot.Bytes(), 3741 } 3742 return err 3743 } 3744 3745 errorBody.Seek(0, io.SeekStart) 3746 3747 return output 3748} 3749 3750func awsRestjson1_deserializeErrorNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3751 output := &types.NotFoundException{} 3752 var buff [1024]byte 3753 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3754 3755 body := io.TeeReader(errorBody, ringBuffer) 3756 decoder := json.NewDecoder(body) 3757 decoder.UseNumber() 3758 var shape interface{} 3759 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3760 var snapshot bytes.Buffer 3761 io.Copy(&snapshot, ringBuffer) 3762 err = &smithy.DeserializationError{ 3763 Err: fmt.Errorf("failed to decode response body, %w", err), 3764 Snapshot: snapshot.Bytes(), 3765 } 3766 return err 3767 } 3768 3769 err := awsRestjson1_deserializeDocumentNotFoundException(&output, shape) 3770 3771 if err != nil { 3772 var snapshot bytes.Buffer 3773 io.Copy(&snapshot, ringBuffer) 3774 err = &smithy.DeserializationError{ 3775 Err: fmt.Errorf("failed to decode response body, %w", err), 3776 Snapshot: snapshot.Bytes(), 3777 } 3778 return err 3779 } 3780 3781 errorBody.Seek(0, io.SeekStart) 3782 3783 return output 3784} 3785 3786func awsRestjson1_deserializeErrorTooManyRequestsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3787 output := &types.TooManyRequestsException{} 3788 var buff [1024]byte 3789 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3790 3791 body := io.TeeReader(errorBody, ringBuffer) 3792 decoder := json.NewDecoder(body) 3793 decoder.UseNumber() 3794 var shape interface{} 3795 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3796 var snapshot bytes.Buffer 3797 io.Copy(&snapshot, ringBuffer) 3798 err = &smithy.DeserializationError{ 3799 Err: fmt.Errorf("failed to decode response body, %w", err), 3800 Snapshot: snapshot.Bytes(), 3801 } 3802 return err 3803 } 3804 3805 err := awsRestjson1_deserializeDocumentTooManyRequestsException(&output, shape) 3806 3807 if err != nil { 3808 var snapshot bytes.Buffer 3809 io.Copy(&snapshot, ringBuffer) 3810 err = &smithy.DeserializationError{ 3811 Err: fmt.Errorf("failed to decode response body, %w", err), 3812 Snapshot: snapshot.Bytes(), 3813 } 3814 return err 3815 } 3816 3817 errorBody.Seek(0, io.SeekStart) 3818 3819 return output 3820} 3821 3822func awsRestjson1_deserializeDocument__listOf__doubleMinNegative60Max6(v *[]float64, value interface{}) error { 3823 if v == nil { 3824 return fmt.Errorf("unexpected nil of type %T", v) 3825 } 3826 if value == nil { 3827 return nil 3828 } 3829 3830 shape, ok := value.([]interface{}) 3831 if !ok { 3832 return fmt.Errorf("unexpected JSON type %v", value) 3833 } 3834 3835 var cv []float64 3836 if *v == nil { 3837 cv = []float64{} 3838 } else { 3839 cv = *v 3840 } 3841 3842 for _, value := range shape { 3843 var col float64 3844 if value != nil { 3845 switch jtv := value.(type) { 3846 case json.Number: 3847 f64, err := jtv.Float64() 3848 if err != nil { 3849 return err 3850 } 3851 col = f64 3852 3853 case string: 3854 var f64 float64 3855 switch { 3856 case strings.EqualFold(jtv, "NaN"): 3857 f64 = math.NaN() 3858 3859 case strings.EqualFold(jtv, "Infinity"): 3860 f64 = math.Inf(1) 3861 3862 case strings.EqualFold(jtv, "-Infinity"): 3863 f64 = math.Inf(-1) 3864 3865 default: 3866 return fmt.Errorf("unknown JSON number value: %s", jtv) 3867 3868 } 3869 col = f64 3870 3871 default: 3872 return fmt.Errorf("expected __doubleMinNegative60Max6 to be a JSON Number, got %T instead", value) 3873 3874 } 3875 } 3876 cv = append(cv, col) 3877 3878 } 3879 *v = cv 3880 return nil 3881} 3882 3883func awsRestjson1_deserializeDocument__listOf__integerMin1Max2147483647(v *[]int32, value interface{}) error { 3884 if v == nil { 3885 return fmt.Errorf("unexpected nil of type %T", v) 3886 } 3887 if value == nil { 3888 return nil 3889 } 3890 3891 shape, ok := value.([]interface{}) 3892 if !ok { 3893 return fmt.Errorf("unexpected JSON type %v", value) 3894 } 3895 3896 var cv []int32 3897 if *v == nil { 3898 cv = []int32{} 3899 } else { 3900 cv = *v 3901 } 3902 3903 for _, value := range shape { 3904 var col int32 3905 if value != nil { 3906 jtv, ok := value.(json.Number) 3907 if !ok { 3908 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 3909 } 3910 i64, err := jtv.Int64() 3911 if err != nil { 3912 return err 3913 } 3914 col = int32(i64) 3915 } 3916 cv = append(cv, col) 3917 3918 } 3919 *v = cv 3920 return nil 3921} 3922 3923func awsRestjson1_deserializeDocument__listOf__integerMin32Max8182(v *[]int32, value interface{}) error { 3924 if v == nil { 3925 return fmt.Errorf("unexpected nil of type %T", v) 3926 } 3927 if value == nil { 3928 return nil 3929 } 3930 3931 shape, ok := value.([]interface{}) 3932 if !ok { 3933 return fmt.Errorf("unexpected JSON type %v", value) 3934 } 3935 3936 var cv []int32 3937 if *v == nil { 3938 cv = []int32{} 3939 } else { 3940 cv = *v 3941 } 3942 3943 for _, value := range shape { 3944 var col int32 3945 if value != nil { 3946 jtv, ok := value.(json.Number) 3947 if !ok { 3948 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 3949 } 3950 i64, err := jtv.Int64() 3951 if err != nil { 3952 return err 3953 } 3954 col = int32(i64) 3955 } 3956 cv = append(cv, col) 3957 3958 } 3959 *v = cv 3960 return nil 3961} 3962 3963func awsRestjson1_deserializeDocument__listOf__integerMinNegative60Max6(v *[]int32, value interface{}) error { 3964 if v == nil { 3965 return fmt.Errorf("unexpected nil of type %T", v) 3966 } 3967 if value == nil { 3968 return nil 3969 } 3970 3971 shape, ok := value.([]interface{}) 3972 if !ok { 3973 return fmt.Errorf("unexpected JSON type %v", value) 3974 } 3975 3976 var cv []int32 3977 if *v == nil { 3978 cv = []int32{} 3979 } else { 3980 cv = *v 3981 } 3982 3983 for _, value := range shape { 3984 var col int32 3985 if value != nil { 3986 jtv, ok := value.(json.Number) 3987 if !ok { 3988 return fmt.Errorf("expected __integerMinNegative60Max6 to be json.Number, got %T instead", value) 3989 } 3990 i64, err := jtv.Int64() 3991 if err != nil { 3992 return err 3993 } 3994 col = int32(i64) 3995 } 3996 cv = append(cv, col) 3997 3998 } 3999 *v = cv 4000 return nil 4001} 4002 4003func awsRestjson1_deserializeDocument__listOf__string(v *[]string, value interface{}) error { 4004 if v == nil { 4005 return fmt.Errorf("unexpected nil of type %T", v) 4006 } 4007 if value == nil { 4008 return nil 4009 } 4010 4011 shape, ok := value.([]interface{}) 4012 if !ok { 4013 return fmt.Errorf("unexpected JSON type %v", value) 4014 } 4015 4016 var cv []string 4017 if *v == nil { 4018 cv = []string{} 4019 } else { 4020 cv = *v 4021 } 4022 4023 for _, value := range shape { 4024 var col string 4025 if value != nil { 4026 jtv, ok := value.(string) 4027 if !ok { 4028 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 4029 } 4030 col = jtv 4031 } 4032 cv = append(cv, col) 4033 4034 } 4035 *v = cv 4036 return nil 4037} 4038 4039func awsRestjson1_deserializeDocument__listOf__stringMin1(v *[]string, value interface{}) error { 4040 if v == nil { 4041 return fmt.Errorf("unexpected nil of type %T", v) 4042 } 4043 if value == nil { 4044 return nil 4045 } 4046 4047 shape, ok := value.([]interface{}) 4048 if !ok { 4049 return fmt.Errorf("unexpected JSON type %v", value) 4050 } 4051 4052 var cv []string 4053 if *v == nil { 4054 cv = []string{} 4055 } else { 4056 cv = *v 4057 } 4058 4059 for _, value := range shape { 4060 var col string 4061 if value != nil { 4062 jtv, ok := value.(string) 4063 if !ok { 4064 return fmt.Errorf("expected __stringMin1 to be of type string, got %T instead", value) 4065 } 4066 col = jtv 4067 } 4068 cv = append(cv, col) 4069 4070 } 4071 *v = cv 4072 return nil 4073} 4074 4075func awsRestjson1_deserializeDocument__listOf__stringMin36Max36Pattern09aFAF809aFAF409aFAF409aFAF409aFAF12(v *[]string, value interface{}) error { 4076 if v == nil { 4077 return fmt.Errorf("unexpected nil of type %T", v) 4078 } 4079 if value == nil { 4080 return nil 4081 } 4082 4083 shape, ok := value.([]interface{}) 4084 if !ok { 4085 return fmt.Errorf("unexpected JSON type %v", value) 4086 } 4087 4088 var cv []string 4089 if *v == nil { 4090 cv = []string{} 4091 } else { 4092 cv = *v 4093 } 4094 4095 for _, value := range shape { 4096 var col string 4097 if value != nil { 4098 jtv, ok := value.(string) 4099 if !ok { 4100 return fmt.Errorf("expected __stringMin36Max36Pattern09aFAF809aFAF409aFAF409aFAF409aFAF12 to be of type string, got %T instead", value) 4101 } 4102 col = jtv 4103 } 4104 cv = append(cv, col) 4105 4106 } 4107 *v = cv 4108 return nil 4109} 4110 4111func awsRestjson1_deserializeDocument__listOf__stringPattern09aFAF809aFAF409aFAF409aFAF409aFAF12(v *[]string, value interface{}) error { 4112 if v == nil { 4113 return fmt.Errorf("unexpected nil of type %T", v) 4114 } 4115 if value == nil { 4116 return nil 4117 } 4118 4119 shape, ok := value.([]interface{}) 4120 if !ok { 4121 return fmt.Errorf("unexpected JSON type %v", value) 4122 } 4123 4124 var cv []string 4125 if *v == nil { 4126 cv = []string{} 4127 } else { 4128 cv = *v 4129 } 4130 4131 for _, value := range shape { 4132 var col string 4133 if value != nil { 4134 jtv, ok := value.(string) 4135 if !ok { 4136 return fmt.Errorf("expected __stringPattern09aFAF809aFAF409aFAF409aFAF409aFAF12 to be of type string, got %T instead", value) 4137 } 4138 col = jtv 4139 } 4140 cv = append(cv, col) 4141 4142 } 4143 *v = cv 4144 return nil 4145} 4146 4147func awsRestjson1_deserializeDocument__listOf__stringPatternS3ASSETMAPXml(v *[]string, value interface{}) error { 4148 if v == nil { 4149 return fmt.Errorf("unexpected nil of type %T", v) 4150 } 4151 if value == nil { 4152 return nil 4153 } 4154 4155 shape, ok := value.([]interface{}) 4156 if !ok { 4157 return fmt.Errorf("unexpected JSON type %v", value) 4158 } 4159 4160 var cv []string 4161 if *v == nil { 4162 cv = []string{} 4163 } else { 4164 cv = *v 4165 } 4166 4167 for _, value := range shape { 4168 var col string 4169 if value != nil { 4170 jtv, ok := value.(string) 4171 if !ok { 4172 return fmt.Errorf("expected __stringPatternS3ASSETMAPXml to be of type string, got %T instead", value) 4173 } 4174 col = jtv 4175 } 4176 cv = append(cv, col) 4177 4178 } 4179 *v = cv 4180 return nil 4181} 4182 4183func awsRestjson1_deserializeDocument__listOfAudioDescription(v *[]types.AudioDescription, value interface{}) error { 4184 if v == nil { 4185 return fmt.Errorf("unexpected nil of type %T", v) 4186 } 4187 if value == nil { 4188 return nil 4189 } 4190 4191 shape, ok := value.([]interface{}) 4192 if !ok { 4193 return fmt.Errorf("unexpected JSON type %v", value) 4194 } 4195 4196 var cv []types.AudioDescription 4197 if *v == nil { 4198 cv = []types.AudioDescription{} 4199 } else { 4200 cv = *v 4201 } 4202 4203 for _, value := range shape { 4204 var col types.AudioDescription 4205 destAddr := &col 4206 if err := awsRestjson1_deserializeDocumentAudioDescription(&destAddr, value); err != nil { 4207 return err 4208 } 4209 col = *destAddr 4210 cv = append(cv, col) 4211 4212 } 4213 *v = cv 4214 return nil 4215} 4216 4217func awsRestjson1_deserializeDocument__listOfCaptionDescription(v *[]types.CaptionDescription, value interface{}) error { 4218 if v == nil { 4219 return fmt.Errorf("unexpected nil of type %T", v) 4220 } 4221 if value == nil { 4222 return nil 4223 } 4224 4225 shape, ok := value.([]interface{}) 4226 if !ok { 4227 return fmt.Errorf("unexpected JSON type %v", value) 4228 } 4229 4230 var cv []types.CaptionDescription 4231 if *v == nil { 4232 cv = []types.CaptionDescription{} 4233 } else { 4234 cv = *v 4235 } 4236 4237 for _, value := range shape { 4238 var col types.CaptionDescription 4239 destAddr := &col 4240 if err := awsRestjson1_deserializeDocumentCaptionDescription(&destAddr, value); err != nil { 4241 return err 4242 } 4243 col = *destAddr 4244 cv = append(cv, col) 4245 4246 } 4247 *v = cv 4248 return nil 4249} 4250 4251func awsRestjson1_deserializeDocument__listOfCaptionDescriptionPreset(v *[]types.CaptionDescriptionPreset, value interface{}) error { 4252 if v == nil { 4253 return fmt.Errorf("unexpected nil of type %T", v) 4254 } 4255 if value == nil { 4256 return nil 4257 } 4258 4259 shape, ok := value.([]interface{}) 4260 if !ok { 4261 return fmt.Errorf("unexpected JSON type %v", value) 4262 } 4263 4264 var cv []types.CaptionDescriptionPreset 4265 if *v == nil { 4266 cv = []types.CaptionDescriptionPreset{} 4267 } else { 4268 cv = *v 4269 } 4270 4271 for _, value := range shape { 4272 var col types.CaptionDescriptionPreset 4273 destAddr := &col 4274 if err := awsRestjson1_deserializeDocumentCaptionDescriptionPreset(&destAddr, value); err != nil { 4275 return err 4276 } 4277 col = *destAddr 4278 cv = append(cv, col) 4279 4280 } 4281 *v = cv 4282 return nil 4283} 4284 4285func awsRestjson1_deserializeDocument__listOfCmafAdditionalManifest(v *[]types.CmafAdditionalManifest, value interface{}) error { 4286 if v == nil { 4287 return fmt.Errorf("unexpected nil of type %T", v) 4288 } 4289 if value == nil { 4290 return nil 4291 } 4292 4293 shape, ok := value.([]interface{}) 4294 if !ok { 4295 return fmt.Errorf("unexpected JSON type %v", value) 4296 } 4297 4298 var cv []types.CmafAdditionalManifest 4299 if *v == nil { 4300 cv = []types.CmafAdditionalManifest{} 4301 } else { 4302 cv = *v 4303 } 4304 4305 for _, value := range shape { 4306 var col types.CmafAdditionalManifest 4307 destAddr := &col 4308 if err := awsRestjson1_deserializeDocumentCmafAdditionalManifest(&destAddr, value); err != nil { 4309 return err 4310 } 4311 col = *destAddr 4312 cv = append(cv, col) 4313 4314 } 4315 *v = cv 4316 return nil 4317} 4318 4319func awsRestjson1_deserializeDocument__listOfDashAdditionalManifest(v *[]types.DashAdditionalManifest, value interface{}) error { 4320 if v == nil { 4321 return fmt.Errorf("unexpected nil of type %T", v) 4322 } 4323 if value == nil { 4324 return nil 4325 } 4326 4327 shape, ok := value.([]interface{}) 4328 if !ok { 4329 return fmt.Errorf("unexpected JSON type %v", value) 4330 } 4331 4332 var cv []types.DashAdditionalManifest 4333 if *v == nil { 4334 cv = []types.DashAdditionalManifest{} 4335 } else { 4336 cv = *v 4337 } 4338 4339 for _, value := range shape { 4340 var col types.DashAdditionalManifest 4341 destAddr := &col 4342 if err := awsRestjson1_deserializeDocumentDashAdditionalManifest(&destAddr, value); err != nil { 4343 return err 4344 } 4345 col = *destAddr 4346 cv = append(cv, col) 4347 4348 } 4349 *v = cv 4350 return nil 4351} 4352 4353func awsRestjson1_deserializeDocument__listOfEndpoint(v *[]types.Endpoint, value interface{}) error { 4354 if v == nil { 4355 return fmt.Errorf("unexpected nil of type %T", v) 4356 } 4357 if value == nil { 4358 return nil 4359 } 4360 4361 shape, ok := value.([]interface{}) 4362 if !ok { 4363 return fmt.Errorf("unexpected JSON type %v", value) 4364 } 4365 4366 var cv []types.Endpoint 4367 if *v == nil { 4368 cv = []types.Endpoint{} 4369 } else { 4370 cv = *v 4371 } 4372 4373 for _, value := range shape { 4374 var col types.Endpoint 4375 destAddr := &col 4376 if err := awsRestjson1_deserializeDocumentEndpoint(&destAddr, value); err != nil { 4377 return err 4378 } 4379 col = *destAddr 4380 cv = append(cv, col) 4381 4382 } 4383 *v = cv 4384 return nil 4385} 4386 4387func awsRestjson1_deserializeDocument__listOfHlsAdditionalManifest(v *[]types.HlsAdditionalManifest, value interface{}) error { 4388 if v == nil { 4389 return fmt.Errorf("unexpected nil of type %T", v) 4390 } 4391 if value == nil { 4392 return nil 4393 } 4394 4395 shape, ok := value.([]interface{}) 4396 if !ok { 4397 return fmt.Errorf("unexpected JSON type %v", value) 4398 } 4399 4400 var cv []types.HlsAdditionalManifest 4401 if *v == nil { 4402 cv = []types.HlsAdditionalManifest{} 4403 } else { 4404 cv = *v 4405 } 4406 4407 for _, value := range shape { 4408 var col types.HlsAdditionalManifest 4409 destAddr := &col 4410 if err := awsRestjson1_deserializeDocumentHlsAdditionalManifest(&destAddr, value); err != nil { 4411 return err 4412 } 4413 col = *destAddr 4414 cv = append(cv, col) 4415 4416 } 4417 *v = cv 4418 return nil 4419} 4420 4421func awsRestjson1_deserializeDocument__listOfHlsAdMarkers(v *[]types.HlsAdMarkers, value interface{}) error { 4422 if v == nil { 4423 return fmt.Errorf("unexpected nil of type %T", v) 4424 } 4425 if value == nil { 4426 return nil 4427 } 4428 4429 shape, ok := value.([]interface{}) 4430 if !ok { 4431 return fmt.Errorf("unexpected JSON type %v", value) 4432 } 4433 4434 var cv []types.HlsAdMarkers 4435 if *v == nil { 4436 cv = []types.HlsAdMarkers{} 4437 } else { 4438 cv = *v 4439 } 4440 4441 for _, value := range shape { 4442 var col types.HlsAdMarkers 4443 if value != nil { 4444 jtv, ok := value.(string) 4445 if !ok { 4446 return fmt.Errorf("expected HlsAdMarkers to be of type string, got %T instead", value) 4447 } 4448 col = types.HlsAdMarkers(jtv) 4449 } 4450 cv = append(cv, col) 4451 4452 } 4453 *v = cv 4454 return nil 4455} 4456 4457func awsRestjson1_deserializeDocument__listOfHlsCaptionLanguageMapping(v *[]types.HlsCaptionLanguageMapping, value interface{}) error { 4458 if v == nil { 4459 return fmt.Errorf("unexpected nil of type %T", v) 4460 } 4461 if value == nil { 4462 return nil 4463 } 4464 4465 shape, ok := value.([]interface{}) 4466 if !ok { 4467 return fmt.Errorf("unexpected JSON type %v", value) 4468 } 4469 4470 var cv []types.HlsCaptionLanguageMapping 4471 if *v == nil { 4472 cv = []types.HlsCaptionLanguageMapping{} 4473 } else { 4474 cv = *v 4475 } 4476 4477 for _, value := range shape { 4478 var col types.HlsCaptionLanguageMapping 4479 destAddr := &col 4480 if err := awsRestjson1_deserializeDocumentHlsCaptionLanguageMapping(&destAddr, value); err != nil { 4481 return err 4482 } 4483 col = *destAddr 4484 cv = append(cv, col) 4485 4486 } 4487 *v = cv 4488 return nil 4489} 4490 4491func awsRestjson1_deserializeDocument__listOfHopDestination(v *[]types.HopDestination, value interface{}) error { 4492 if v == nil { 4493 return fmt.Errorf("unexpected nil of type %T", v) 4494 } 4495 if value == nil { 4496 return nil 4497 } 4498 4499 shape, ok := value.([]interface{}) 4500 if !ok { 4501 return fmt.Errorf("unexpected JSON type %v", value) 4502 } 4503 4504 var cv []types.HopDestination 4505 if *v == nil { 4506 cv = []types.HopDestination{} 4507 } else { 4508 cv = *v 4509 } 4510 4511 for _, value := range shape { 4512 var col types.HopDestination 4513 destAddr := &col 4514 if err := awsRestjson1_deserializeDocumentHopDestination(&destAddr, value); err != nil { 4515 return err 4516 } 4517 col = *destAddr 4518 cv = append(cv, col) 4519 4520 } 4521 *v = cv 4522 return nil 4523} 4524 4525func awsRestjson1_deserializeDocument__listOfId3Insertion(v *[]types.Id3Insertion, value interface{}) error { 4526 if v == nil { 4527 return fmt.Errorf("unexpected nil of type %T", v) 4528 } 4529 if value == nil { 4530 return nil 4531 } 4532 4533 shape, ok := value.([]interface{}) 4534 if !ok { 4535 return fmt.Errorf("unexpected JSON type %v", value) 4536 } 4537 4538 var cv []types.Id3Insertion 4539 if *v == nil { 4540 cv = []types.Id3Insertion{} 4541 } else { 4542 cv = *v 4543 } 4544 4545 for _, value := range shape { 4546 var col types.Id3Insertion 4547 destAddr := &col 4548 if err := awsRestjson1_deserializeDocumentId3Insertion(&destAddr, value); err != nil { 4549 return err 4550 } 4551 col = *destAddr 4552 cv = append(cv, col) 4553 4554 } 4555 *v = cv 4556 return nil 4557} 4558 4559func awsRestjson1_deserializeDocument__listOfInput(v *[]types.Input, value interface{}) error { 4560 if v == nil { 4561 return fmt.Errorf("unexpected nil of type %T", v) 4562 } 4563 if value == nil { 4564 return nil 4565 } 4566 4567 shape, ok := value.([]interface{}) 4568 if !ok { 4569 return fmt.Errorf("unexpected JSON type %v", value) 4570 } 4571 4572 var cv []types.Input 4573 if *v == nil { 4574 cv = []types.Input{} 4575 } else { 4576 cv = *v 4577 } 4578 4579 for _, value := range shape { 4580 var col types.Input 4581 destAddr := &col 4582 if err := awsRestjson1_deserializeDocumentInput(&destAddr, value); err != nil { 4583 return err 4584 } 4585 col = *destAddr 4586 cv = append(cv, col) 4587 4588 } 4589 *v = cv 4590 return nil 4591} 4592 4593func awsRestjson1_deserializeDocument__listOfInputClipping(v *[]types.InputClipping, value interface{}) error { 4594 if v == nil { 4595 return fmt.Errorf("unexpected nil of type %T", v) 4596 } 4597 if value == nil { 4598 return nil 4599 } 4600 4601 shape, ok := value.([]interface{}) 4602 if !ok { 4603 return fmt.Errorf("unexpected JSON type %v", value) 4604 } 4605 4606 var cv []types.InputClipping 4607 if *v == nil { 4608 cv = []types.InputClipping{} 4609 } else { 4610 cv = *v 4611 } 4612 4613 for _, value := range shape { 4614 var col types.InputClipping 4615 destAddr := &col 4616 if err := awsRestjson1_deserializeDocumentInputClipping(&destAddr, value); err != nil { 4617 return err 4618 } 4619 col = *destAddr 4620 cv = append(cv, col) 4621 4622 } 4623 *v = cv 4624 return nil 4625} 4626 4627func awsRestjson1_deserializeDocument__listOfInputTemplate(v *[]types.InputTemplate, value interface{}) error { 4628 if v == nil { 4629 return fmt.Errorf("unexpected nil of type %T", v) 4630 } 4631 if value == nil { 4632 return nil 4633 } 4634 4635 shape, ok := value.([]interface{}) 4636 if !ok { 4637 return fmt.Errorf("unexpected JSON type %v", value) 4638 } 4639 4640 var cv []types.InputTemplate 4641 if *v == nil { 4642 cv = []types.InputTemplate{} 4643 } else { 4644 cv = *v 4645 } 4646 4647 for _, value := range shape { 4648 var col types.InputTemplate 4649 destAddr := &col 4650 if err := awsRestjson1_deserializeDocumentInputTemplate(&destAddr, value); err != nil { 4651 return err 4652 } 4653 col = *destAddr 4654 cv = append(cv, col) 4655 4656 } 4657 *v = cv 4658 return nil 4659} 4660 4661func awsRestjson1_deserializeDocument__listOfInsertableImage(v *[]types.InsertableImage, value interface{}) error { 4662 if v == nil { 4663 return fmt.Errorf("unexpected nil of type %T", v) 4664 } 4665 if value == nil { 4666 return nil 4667 } 4668 4669 shape, ok := value.([]interface{}) 4670 if !ok { 4671 return fmt.Errorf("unexpected JSON type %v", value) 4672 } 4673 4674 var cv []types.InsertableImage 4675 if *v == nil { 4676 cv = []types.InsertableImage{} 4677 } else { 4678 cv = *v 4679 } 4680 4681 for _, value := range shape { 4682 var col types.InsertableImage 4683 destAddr := &col 4684 if err := awsRestjson1_deserializeDocumentInsertableImage(&destAddr, value); err != nil { 4685 return err 4686 } 4687 col = *destAddr 4688 cv = append(cv, col) 4689 4690 } 4691 *v = cv 4692 return nil 4693} 4694 4695func awsRestjson1_deserializeDocument__listOfJob(v *[]types.Job, value interface{}) error { 4696 if v == nil { 4697 return fmt.Errorf("unexpected nil of type %T", v) 4698 } 4699 if value == nil { 4700 return nil 4701 } 4702 4703 shape, ok := value.([]interface{}) 4704 if !ok { 4705 return fmt.Errorf("unexpected JSON type %v", value) 4706 } 4707 4708 var cv []types.Job 4709 if *v == nil { 4710 cv = []types.Job{} 4711 } else { 4712 cv = *v 4713 } 4714 4715 for _, value := range shape { 4716 var col types.Job 4717 destAddr := &col 4718 if err := awsRestjson1_deserializeDocumentJob(&destAddr, value); err != nil { 4719 return err 4720 } 4721 col = *destAddr 4722 cv = append(cv, col) 4723 4724 } 4725 *v = cv 4726 return nil 4727} 4728 4729func awsRestjson1_deserializeDocument__listOfJobTemplate(v *[]types.JobTemplate, value interface{}) error { 4730 if v == nil { 4731 return fmt.Errorf("unexpected nil of type %T", v) 4732 } 4733 if value == nil { 4734 return nil 4735 } 4736 4737 shape, ok := value.([]interface{}) 4738 if !ok { 4739 return fmt.Errorf("unexpected JSON type %v", value) 4740 } 4741 4742 var cv []types.JobTemplate 4743 if *v == nil { 4744 cv = []types.JobTemplate{} 4745 } else { 4746 cv = *v 4747 } 4748 4749 for _, value := range shape { 4750 var col types.JobTemplate 4751 destAddr := &col 4752 if err := awsRestjson1_deserializeDocumentJobTemplate(&destAddr, value); err != nil { 4753 return err 4754 } 4755 col = *destAddr 4756 cv = append(cv, col) 4757 4758 } 4759 *v = cv 4760 return nil 4761} 4762 4763func awsRestjson1_deserializeDocument__listOfMsSmoothAdditionalManifest(v *[]types.MsSmoothAdditionalManifest, value interface{}) error { 4764 if v == nil { 4765 return fmt.Errorf("unexpected nil of type %T", v) 4766 } 4767 if value == nil { 4768 return nil 4769 } 4770 4771 shape, ok := value.([]interface{}) 4772 if !ok { 4773 return fmt.Errorf("unexpected JSON type %v", value) 4774 } 4775 4776 var cv []types.MsSmoothAdditionalManifest 4777 if *v == nil { 4778 cv = []types.MsSmoothAdditionalManifest{} 4779 } else { 4780 cv = *v 4781 } 4782 4783 for _, value := range shape { 4784 var col types.MsSmoothAdditionalManifest 4785 destAddr := &col 4786 if err := awsRestjson1_deserializeDocumentMsSmoothAdditionalManifest(&destAddr, value); err != nil { 4787 return err 4788 } 4789 col = *destAddr 4790 cv = append(cv, col) 4791 4792 } 4793 *v = cv 4794 return nil 4795} 4796 4797func awsRestjson1_deserializeDocument__listOfOutput(v *[]types.Output, value interface{}) error { 4798 if v == nil { 4799 return fmt.Errorf("unexpected nil of type %T", v) 4800 } 4801 if value == nil { 4802 return nil 4803 } 4804 4805 shape, ok := value.([]interface{}) 4806 if !ok { 4807 return fmt.Errorf("unexpected JSON type %v", value) 4808 } 4809 4810 var cv []types.Output 4811 if *v == nil { 4812 cv = []types.Output{} 4813 } else { 4814 cv = *v 4815 } 4816 4817 for _, value := range shape { 4818 var col types.Output 4819 destAddr := &col 4820 if err := awsRestjson1_deserializeDocumentOutput(&destAddr, value); err != nil { 4821 return err 4822 } 4823 col = *destAddr 4824 cv = append(cv, col) 4825 4826 } 4827 *v = cv 4828 return nil 4829} 4830 4831func awsRestjson1_deserializeDocument__listOfOutputChannelMapping(v *[]types.OutputChannelMapping, value interface{}) error { 4832 if v == nil { 4833 return fmt.Errorf("unexpected nil of type %T", v) 4834 } 4835 if value == nil { 4836 return nil 4837 } 4838 4839 shape, ok := value.([]interface{}) 4840 if !ok { 4841 return fmt.Errorf("unexpected JSON type %v", value) 4842 } 4843 4844 var cv []types.OutputChannelMapping 4845 if *v == nil { 4846 cv = []types.OutputChannelMapping{} 4847 } else { 4848 cv = *v 4849 } 4850 4851 for _, value := range shape { 4852 var col types.OutputChannelMapping 4853 destAddr := &col 4854 if err := awsRestjson1_deserializeDocumentOutputChannelMapping(&destAddr, value); err != nil { 4855 return err 4856 } 4857 col = *destAddr 4858 cv = append(cv, col) 4859 4860 } 4861 *v = cv 4862 return nil 4863} 4864 4865func awsRestjson1_deserializeDocument__listOfOutputDetail(v *[]types.OutputDetail, value interface{}) error { 4866 if v == nil { 4867 return fmt.Errorf("unexpected nil of type %T", v) 4868 } 4869 if value == nil { 4870 return nil 4871 } 4872 4873 shape, ok := value.([]interface{}) 4874 if !ok { 4875 return fmt.Errorf("unexpected JSON type %v", value) 4876 } 4877 4878 var cv []types.OutputDetail 4879 if *v == nil { 4880 cv = []types.OutputDetail{} 4881 } else { 4882 cv = *v 4883 } 4884 4885 for _, value := range shape { 4886 var col types.OutputDetail 4887 destAddr := &col 4888 if err := awsRestjson1_deserializeDocumentOutputDetail(&destAddr, value); err != nil { 4889 return err 4890 } 4891 col = *destAddr 4892 cv = append(cv, col) 4893 4894 } 4895 *v = cv 4896 return nil 4897} 4898 4899func awsRestjson1_deserializeDocument__listOfOutputGroup(v *[]types.OutputGroup, value interface{}) error { 4900 if v == nil { 4901 return fmt.Errorf("unexpected nil of type %T", v) 4902 } 4903 if value == nil { 4904 return nil 4905 } 4906 4907 shape, ok := value.([]interface{}) 4908 if !ok { 4909 return fmt.Errorf("unexpected JSON type %v", value) 4910 } 4911 4912 var cv []types.OutputGroup 4913 if *v == nil { 4914 cv = []types.OutputGroup{} 4915 } else { 4916 cv = *v 4917 } 4918 4919 for _, value := range shape { 4920 var col types.OutputGroup 4921 destAddr := &col 4922 if err := awsRestjson1_deserializeDocumentOutputGroup(&destAddr, value); err != nil { 4923 return err 4924 } 4925 col = *destAddr 4926 cv = append(cv, col) 4927 4928 } 4929 *v = cv 4930 return nil 4931} 4932 4933func awsRestjson1_deserializeDocument__listOfOutputGroupDetail(v *[]types.OutputGroupDetail, value interface{}) error { 4934 if v == nil { 4935 return fmt.Errorf("unexpected nil of type %T", v) 4936 } 4937 if value == nil { 4938 return nil 4939 } 4940 4941 shape, ok := value.([]interface{}) 4942 if !ok { 4943 return fmt.Errorf("unexpected JSON type %v", value) 4944 } 4945 4946 var cv []types.OutputGroupDetail 4947 if *v == nil { 4948 cv = []types.OutputGroupDetail{} 4949 } else { 4950 cv = *v 4951 } 4952 4953 for _, value := range shape { 4954 var col types.OutputGroupDetail 4955 destAddr := &col 4956 if err := awsRestjson1_deserializeDocumentOutputGroupDetail(&destAddr, value); err != nil { 4957 return err 4958 } 4959 col = *destAddr 4960 cv = append(cv, col) 4961 4962 } 4963 *v = cv 4964 return nil 4965} 4966 4967func awsRestjson1_deserializeDocument__listOfPreset(v *[]types.Preset, value interface{}) error { 4968 if v == nil { 4969 return fmt.Errorf("unexpected nil of type %T", v) 4970 } 4971 if value == nil { 4972 return nil 4973 } 4974 4975 shape, ok := value.([]interface{}) 4976 if !ok { 4977 return fmt.Errorf("unexpected JSON type %v", value) 4978 } 4979 4980 var cv []types.Preset 4981 if *v == nil { 4982 cv = []types.Preset{} 4983 } else { 4984 cv = *v 4985 } 4986 4987 for _, value := range shape { 4988 var col types.Preset 4989 destAddr := &col 4990 if err := awsRestjson1_deserializeDocumentPreset(&destAddr, value); err != nil { 4991 return err 4992 } 4993 col = *destAddr 4994 cv = append(cv, col) 4995 4996 } 4997 *v = cv 4998 return nil 4999} 5000 5001func awsRestjson1_deserializeDocument__listOfQueue(v *[]types.Queue, value interface{}) error { 5002 if v == nil { 5003 return fmt.Errorf("unexpected nil of type %T", v) 5004 } 5005 if value == nil { 5006 return nil 5007 } 5008 5009 shape, ok := value.([]interface{}) 5010 if !ok { 5011 return fmt.Errorf("unexpected JSON type %v", value) 5012 } 5013 5014 var cv []types.Queue 5015 if *v == nil { 5016 cv = []types.Queue{} 5017 } else { 5018 cv = *v 5019 } 5020 5021 for _, value := range shape { 5022 var col types.Queue 5023 destAddr := &col 5024 if err := awsRestjson1_deserializeDocumentQueue(&destAddr, value); err != nil { 5025 return err 5026 } 5027 col = *destAddr 5028 cv = append(cv, col) 5029 5030 } 5031 *v = cv 5032 return nil 5033} 5034 5035func awsRestjson1_deserializeDocument__listOfQueueTransition(v *[]types.QueueTransition, value interface{}) error { 5036 if v == nil { 5037 return fmt.Errorf("unexpected nil of type %T", v) 5038 } 5039 if value == nil { 5040 return nil 5041 } 5042 5043 shape, ok := value.([]interface{}) 5044 if !ok { 5045 return fmt.Errorf("unexpected JSON type %v", value) 5046 } 5047 5048 var cv []types.QueueTransition 5049 if *v == nil { 5050 cv = []types.QueueTransition{} 5051 } else { 5052 cv = *v 5053 } 5054 5055 for _, value := range shape { 5056 var col types.QueueTransition 5057 destAddr := &col 5058 if err := awsRestjson1_deserializeDocumentQueueTransition(&destAddr, value); err != nil { 5059 return err 5060 } 5061 col = *destAddr 5062 cv = append(cv, col) 5063 5064 } 5065 *v = cv 5066 return nil 5067} 5068 5069func awsRestjson1_deserializeDocument__listOfTeletextPageType(v *[]types.TeletextPageType, value interface{}) error { 5070 if v == nil { 5071 return fmt.Errorf("unexpected nil of type %T", v) 5072 } 5073 if value == nil { 5074 return nil 5075 } 5076 5077 shape, ok := value.([]interface{}) 5078 if !ok { 5079 return fmt.Errorf("unexpected JSON type %v", value) 5080 } 5081 5082 var cv []types.TeletextPageType 5083 if *v == nil { 5084 cv = []types.TeletextPageType{} 5085 } else { 5086 cv = *v 5087 } 5088 5089 for _, value := range shape { 5090 var col types.TeletextPageType 5091 if value != nil { 5092 jtv, ok := value.(string) 5093 if !ok { 5094 return fmt.Errorf("expected TeletextPageType to be of type string, got %T instead", value) 5095 } 5096 col = types.TeletextPageType(jtv) 5097 } 5098 cv = append(cv, col) 5099 5100 } 5101 *v = cv 5102 return nil 5103} 5104 5105func awsRestjson1_deserializeDocument__mapOf__string(v *map[string]string, value interface{}) error { 5106 if v == nil { 5107 return fmt.Errorf("unexpected nil of type %T", v) 5108 } 5109 if value == nil { 5110 return nil 5111 } 5112 5113 shape, ok := value.(map[string]interface{}) 5114 if !ok { 5115 return fmt.Errorf("unexpected JSON type %v", value) 5116 } 5117 5118 var mv map[string]string 5119 if *v == nil { 5120 mv = map[string]string{} 5121 } else { 5122 mv = *v 5123 } 5124 5125 for key, value := range shape { 5126 var parsedVal string 5127 if value != nil { 5128 jtv, ok := value.(string) 5129 if !ok { 5130 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 5131 } 5132 parsedVal = jtv 5133 } 5134 mv[key] = parsedVal 5135 5136 } 5137 *v = mv 5138 return nil 5139} 5140 5141func awsRestjson1_deserializeDocument__mapOfAudioSelector(v *map[string]types.AudioSelector, value interface{}) error { 5142 if v == nil { 5143 return fmt.Errorf("unexpected nil of type %T", v) 5144 } 5145 if value == nil { 5146 return nil 5147 } 5148 5149 shape, ok := value.(map[string]interface{}) 5150 if !ok { 5151 return fmt.Errorf("unexpected JSON type %v", value) 5152 } 5153 5154 var mv map[string]types.AudioSelector 5155 if *v == nil { 5156 mv = map[string]types.AudioSelector{} 5157 } else { 5158 mv = *v 5159 } 5160 5161 for key, value := range shape { 5162 var parsedVal types.AudioSelector 5163 mapVar := parsedVal 5164 destAddr := &mapVar 5165 if err := awsRestjson1_deserializeDocumentAudioSelector(&destAddr, value); err != nil { 5166 return err 5167 } 5168 parsedVal = *destAddr 5169 mv[key] = parsedVal 5170 5171 } 5172 *v = mv 5173 return nil 5174} 5175 5176func awsRestjson1_deserializeDocument__mapOfAudioSelectorGroup(v *map[string]types.AudioSelectorGroup, value interface{}) error { 5177 if v == nil { 5178 return fmt.Errorf("unexpected nil of type %T", v) 5179 } 5180 if value == nil { 5181 return nil 5182 } 5183 5184 shape, ok := value.(map[string]interface{}) 5185 if !ok { 5186 return fmt.Errorf("unexpected JSON type %v", value) 5187 } 5188 5189 var mv map[string]types.AudioSelectorGroup 5190 if *v == nil { 5191 mv = map[string]types.AudioSelectorGroup{} 5192 } else { 5193 mv = *v 5194 } 5195 5196 for key, value := range shape { 5197 var parsedVal types.AudioSelectorGroup 5198 mapVar := parsedVal 5199 destAddr := &mapVar 5200 if err := awsRestjson1_deserializeDocumentAudioSelectorGroup(&destAddr, value); err != nil { 5201 return err 5202 } 5203 parsedVal = *destAddr 5204 mv[key] = parsedVal 5205 5206 } 5207 *v = mv 5208 return nil 5209} 5210 5211func awsRestjson1_deserializeDocument__mapOfCaptionSelector(v *map[string]types.CaptionSelector, value interface{}) error { 5212 if v == nil { 5213 return fmt.Errorf("unexpected nil of type %T", v) 5214 } 5215 if value == nil { 5216 return nil 5217 } 5218 5219 shape, ok := value.(map[string]interface{}) 5220 if !ok { 5221 return fmt.Errorf("unexpected JSON type %v", value) 5222 } 5223 5224 var mv map[string]types.CaptionSelector 5225 if *v == nil { 5226 mv = map[string]types.CaptionSelector{} 5227 } else { 5228 mv = *v 5229 } 5230 5231 for key, value := range shape { 5232 var parsedVal types.CaptionSelector 5233 mapVar := parsedVal 5234 destAddr := &mapVar 5235 if err := awsRestjson1_deserializeDocumentCaptionSelector(&destAddr, value); err != nil { 5236 return err 5237 } 5238 parsedVal = *destAddr 5239 mv[key] = parsedVal 5240 5241 } 5242 *v = mv 5243 return nil 5244} 5245 5246func awsRestjson1_deserializeDocumentAacSettings(v **types.AacSettings, value interface{}) error { 5247 if v == nil { 5248 return fmt.Errorf("unexpected nil of type %T", v) 5249 } 5250 if value == nil { 5251 return nil 5252 } 5253 5254 shape, ok := value.(map[string]interface{}) 5255 if !ok { 5256 return fmt.Errorf("unexpected JSON type %v", value) 5257 } 5258 5259 var sv *types.AacSettings 5260 if *v == nil { 5261 sv = &types.AacSettings{} 5262 } else { 5263 sv = *v 5264 } 5265 5266 for key, value := range shape { 5267 switch key { 5268 case "audioDescriptionBroadcasterMix": 5269 if value != nil { 5270 jtv, ok := value.(string) 5271 if !ok { 5272 return fmt.Errorf("expected AacAudioDescriptionBroadcasterMix to be of type string, got %T instead", value) 5273 } 5274 sv.AudioDescriptionBroadcasterMix = types.AacAudioDescriptionBroadcasterMix(jtv) 5275 } 5276 5277 case "bitrate": 5278 if value != nil { 5279 jtv, ok := value.(json.Number) 5280 if !ok { 5281 return fmt.Errorf("expected __integerMin6000Max1024000 to be json.Number, got %T instead", value) 5282 } 5283 i64, err := jtv.Int64() 5284 if err != nil { 5285 return err 5286 } 5287 sv.Bitrate = int32(i64) 5288 } 5289 5290 case "codecProfile": 5291 if value != nil { 5292 jtv, ok := value.(string) 5293 if !ok { 5294 return fmt.Errorf("expected AacCodecProfile to be of type string, got %T instead", value) 5295 } 5296 sv.CodecProfile = types.AacCodecProfile(jtv) 5297 } 5298 5299 case "codingMode": 5300 if value != nil { 5301 jtv, ok := value.(string) 5302 if !ok { 5303 return fmt.Errorf("expected AacCodingMode to be of type string, got %T instead", value) 5304 } 5305 sv.CodingMode = types.AacCodingMode(jtv) 5306 } 5307 5308 case "rateControlMode": 5309 if value != nil { 5310 jtv, ok := value.(string) 5311 if !ok { 5312 return fmt.Errorf("expected AacRateControlMode to be of type string, got %T instead", value) 5313 } 5314 sv.RateControlMode = types.AacRateControlMode(jtv) 5315 } 5316 5317 case "rawFormat": 5318 if value != nil { 5319 jtv, ok := value.(string) 5320 if !ok { 5321 return fmt.Errorf("expected AacRawFormat to be of type string, got %T instead", value) 5322 } 5323 sv.RawFormat = types.AacRawFormat(jtv) 5324 } 5325 5326 case "sampleRate": 5327 if value != nil { 5328 jtv, ok := value.(json.Number) 5329 if !ok { 5330 return fmt.Errorf("expected __integerMin8000Max96000 to be json.Number, got %T instead", value) 5331 } 5332 i64, err := jtv.Int64() 5333 if err != nil { 5334 return err 5335 } 5336 sv.SampleRate = int32(i64) 5337 } 5338 5339 case "specification": 5340 if value != nil { 5341 jtv, ok := value.(string) 5342 if !ok { 5343 return fmt.Errorf("expected AacSpecification to be of type string, got %T instead", value) 5344 } 5345 sv.Specification = types.AacSpecification(jtv) 5346 } 5347 5348 case "vbrQuality": 5349 if value != nil { 5350 jtv, ok := value.(string) 5351 if !ok { 5352 return fmt.Errorf("expected AacVbrQuality to be of type string, got %T instead", value) 5353 } 5354 sv.VbrQuality = types.AacVbrQuality(jtv) 5355 } 5356 5357 default: 5358 _, _ = key, value 5359 5360 } 5361 } 5362 *v = sv 5363 return nil 5364} 5365 5366func awsRestjson1_deserializeDocumentAc3Settings(v **types.Ac3Settings, value interface{}) error { 5367 if v == nil { 5368 return fmt.Errorf("unexpected nil of type %T", v) 5369 } 5370 if value == nil { 5371 return nil 5372 } 5373 5374 shape, ok := value.(map[string]interface{}) 5375 if !ok { 5376 return fmt.Errorf("unexpected JSON type %v", value) 5377 } 5378 5379 var sv *types.Ac3Settings 5380 if *v == nil { 5381 sv = &types.Ac3Settings{} 5382 } else { 5383 sv = *v 5384 } 5385 5386 for key, value := range shape { 5387 switch key { 5388 case "bitrate": 5389 if value != nil { 5390 jtv, ok := value.(json.Number) 5391 if !ok { 5392 return fmt.Errorf("expected __integerMin64000Max640000 to be json.Number, got %T instead", value) 5393 } 5394 i64, err := jtv.Int64() 5395 if err != nil { 5396 return err 5397 } 5398 sv.Bitrate = int32(i64) 5399 } 5400 5401 case "bitstreamMode": 5402 if value != nil { 5403 jtv, ok := value.(string) 5404 if !ok { 5405 return fmt.Errorf("expected Ac3BitstreamMode to be of type string, got %T instead", value) 5406 } 5407 sv.BitstreamMode = types.Ac3BitstreamMode(jtv) 5408 } 5409 5410 case "codingMode": 5411 if value != nil { 5412 jtv, ok := value.(string) 5413 if !ok { 5414 return fmt.Errorf("expected Ac3CodingMode to be of type string, got %T instead", value) 5415 } 5416 sv.CodingMode = types.Ac3CodingMode(jtv) 5417 } 5418 5419 case "dialnorm": 5420 if value != nil { 5421 jtv, ok := value.(json.Number) 5422 if !ok { 5423 return fmt.Errorf("expected __integerMin1Max31 to be json.Number, got %T instead", value) 5424 } 5425 i64, err := jtv.Int64() 5426 if err != nil { 5427 return err 5428 } 5429 sv.Dialnorm = int32(i64) 5430 } 5431 5432 case "dynamicRangeCompressionLine": 5433 if value != nil { 5434 jtv, ok := value.(string) 5435 if !ok { 5436 return fmt.Errorf("expected Ac3DynamicRangeCompressionLine to be of type string, got %T instead", value) 5437 } 5438 sv.DynamicRangeCompressionLine = types.Ac3DynamicRangeCompressionLine(jtv) 5439 } 5440 5441 case "dynamicRangeCompressionProfile": 5442 if value != nil { 5443 jtv, ok := value.(string) 5444 if !ok { 5445 return fmt.Errorf("expected Ac3DynamicRangeCompressionProfile to be of type string, got %T instead", value) 5446 } 5447 sv.DynamicRangeCompressionProfile = types.Ac3DynamicRangeCompressionProfile(jtv) 5448 } 5449 5450 case "dynamicRangeCompressionRf": 5451 if value != nil { 5452 jtv, ok := value.(string) 5453 if !ok { 5454 return fmt.Errorf("expected Ac3DynamicRangeCompressionRf to be of type string, got %T instead", value) 5455 } 5456 sv.DynamicRangeCompressionRf = types.Ac3DynamicRangeCompressionRf(jtv) 5457 } 5458 5459 case "lfeFilter": 5460 if value != nil { 5461 jtv, ok := value.(string) 5462 if !ok { 5463 return fmt.Errorf("expected Ac3LfeFilter to be of type string, got %T instead", value) 5464 } 5465 sv.LfeFilter = types.Ac3LfeFilter(jtv) 5466 } 5467 5468 case "metadataControl": 5469 if value != nil { 5470 jtv, ok := value.(string) 5471 if !ok { 5472 return fmt.Errorf("expected Ac3MetadataControl to be of type string, got %T instead", value) 5473 } 5474 sv.MetadataControl = types.Ac3MetadataControl(jtv) 5475 } 5476 5477 case "sampleRate": 5478 if value != nil { 5479 jtv, ok := value.(json.Number) 5480 if !ok { 5481 return fmt.Errorf("expected __integerMin48000Max48000 to be json.Number, got %T instead", value) 5482 } 5483 i64, err := jtv.Int64() 5484 if err != nil { 5485 return err 5486 } 5487 sv.SampleRate = int32(i64) 5488 } 5489 5490 default: 5491 _, _ = key, value 5492 5493 } 5494 } 5495 *v = sv 5496 return nil 5497} 5498 5499func awsRestjson1_deserializeDocumentAccelerationSettings(v **types.AccelerationSettings, value interface{}) error { 5500 if v == nil { 5501 return fmt.Errorf("unexpected nil of type %T", v) 5502 } 5503 if value == nil { 5504 return nil 5505 } 5506 5507 shape, ok := value.(map[string]interface{}) 5508 if !ok { 5509 return fmt.Errorf("unexpected JSON type %v", value) 5510 } 5511 5512 var sv *types.AccelerationSettings 5513 if *v == nil { 5514 sv = &types.AccelerationSettings{} 5515 } else { 5516 sv = *v 5517 } 5518 5519 for key, value := range shape { 5520 switch key { 5521 case "mode": 5522 if value != nil { 5523 jtv, ok := value.(string) 5524 if !ok { 5525 return fmt.Errorf("expected AccelerationMode to be of type string, got %T instead", value) 5526 } 5527 sv.Mode = types.AccelerationMode(jtv) 5528 } 5529 5530 default: 5531 _, _ = key, value 5532 5533 } 5534 } 5535 *v = sv 5536 return nil 5537} 5538 5539func awsRestjson1_deserializeDocumentAiffSettings(v **types.AiffSettings, value interface{}) error { 5540 if v == nil { 5541 return fmt.Errorf("unexpected nil of type %T", v) 5542 } 5543 if value == nil { 5544 return nil 5545 } 5546 5547 shape, ok := value.(map[string]interface{}) 5548 if !ok { 5549 return fmt.Errorf("unexpected JSON type %v", value) 5550 } 5551 5552 var sv *types.AiffSettings 5553 if *v == nil { 5554 sv = &types.AiffSettings{} 5555 } else { 5556 sv = *v 5557 } 5558 5559 for key, value := range shape { 5560 switch key { 5561 case "bitDepth": 5562 if value != nil { 5563 jtv, ok := value.(json.Number) 5564 if !ok { 5565 return fmt.Errorf("expected __integerMin16Max24 to be json.Number, got %T instead", value) 5566 } 5567 i64, err := jtv.Int64() 5568 if err != nil { 5569 return err 5570 } 5571 sv.BitDepth = int32(i64) 5572 } 5573 5574 case "channels": 5575 if value != nil { 5576 jtv, ok := value.(json.Number) 5577 if !ok { 5578 return fmt.Errorf("expected __integerMin1Max64 to be json.Number, got %T instead", value) 5579 } 5580 i64, err := jtv.Int64() 5581 if err != nil { 5582 return err 5583 } 5584 sv.Channels = int32(i64) 5585 } 5586 5587 case "sampleRate": 5588 if value != nil { 5589 jtv, ok := value.(json.Number) 5590 if !ok { 5591 return fmt.Errorf("expected __integerMin8000Max192000 to be json.Number, got %T instead", value) 5592 } 5593 i64, err := jtv.Int64() 5594 if err != nil { 5595 return err 5596 } 5597 sv.SampleRate = int32(i64) 5598 } 5599 5600 default: 5601 _, _ = key, value 5602 5603 } 5604 } 5605 *v = sv 5606 return nil 5607} 5608 5609func awsRestjson1_deserializeDocumentAncillarySourceSettings(v **types.AncillarySourceSettings, value interface{}) error { 5610 if v == nil { 5611 return fmt.Errorf("unexpected nil of type %T", v) 5612 } 5613 if value == nil { 5614 return nil 5615 } 5616 5617 shape, ok := value.(map[string]interface{}) 5618 if !ok { 5619 return fmt.Errorf("unexpected JSON type %v", value) 5620 } 5621 5622 var sv *types.AncillarySourceSettings 5623 if *v == nil { 5624 sv = &types.AncillarySourceSettings{} 5625 } else { 5626 sv = *v 5627 } 5628 5629 for key, value := range shape { 5630 switch key { 5631 case "convert608To708": 5632 if value != nil { 5633 jtv, ok := value.(string) 5634 if !ok { 5635 return fmt.Errorf("expected AncillaryConvert608To708 to be of type string, got %T instead", value) 5636 } 5637 sv.Convert608To708 = types.AncillaryConvert608To708(jtv) 5638 } 5639 5640 case "sourceAncillaryChannelNumber": 5641 if value != nil { 5642 jtv, ok := value.(json.Number) 5643 if !ok { 5644 return fmt.Errorf("expected __integerMin1Max4 to be json.Number, got %T instead", value) 5645 } 5646 i64, err := jtv.Int64() 5647 if err != nil { 5648 return err 5649 } 5650 sv.SourceAncillaryChannelNumber = int32(i64) 5651 } 5652 5653 case "terminateCaptions": 5654 if value != nil { 5655 jtv, ok := value.(string) 5656 if !ok { 5657 return fmt.Errorf("expected AncillaryTerminateCaptions to be of type string, got %T instead", value) 5658 } 5659 sv.TerminateCaptions = types.AncillaryTerminateCaptions(jtv) 5660 } 5661 5662 default: 5663 _, _ = key, value 5664 5665 } 5666 } 5667 *v = sv 5668 return nil 5669} 5670 5671func awsRestjson1_deserializeDocumentAudioChannelTaggingSettings(v **types.AudioChannelTaggingSettings, value interface{}) error { 5672 if v == nil { 5673 return fmt.Errorf("unexpected nil of type %T", v) 5674 } 5675 if value == nil { 5676 return nil 5677 } 5678 5679 shape, ok := value.(map[string]interface{}) 5680 if !ok { 5681 return fmt.Errorf("unexpected JSON type %v", value) 5682 } 5683 5684 var sv *types.AudioChannelTaggingSettings 5685 if *v == nil { 5686 sv = &types.AudioChannelTaggingSettings{} 5687 } else { 5688 sv = *v 5689 } 5690 5691 for key, value := range shape { 5692 switch key { 5693 case "channelTag": 5694 if value != nil { 5695 jtv, ok := value.(string) 5696 if !ok { 5697 return fmt.Errorf("expected AudioChannelTag to be of type string, got %T instead", value) 5698 } 5699 sv.ChannelTag = types.AudioChannelTag(jtv) 5700 } 5701 5702 default: 5703 _, _ = key, value 5704 5705 } 5706 } 5707 *v = sv 5708 return nil 5709} 5710 5711func awsRestjson1_deserializeDocumentAudioCodecSettings(v **types.AudioCodecSettings, value interface{}) error { 5712 if v == nil { 5713 return fmt.Errorf("unexpected nil of type %T", v) 5714 } 5715 if value == nil { 5716 return nil 5717 } 5718 5719 shape, ok := value.(map[string]interface{}) 5720 if !ok { 5721 return fmt.Errorf("unexpected JSON type %v", value) 5722 } 5723 5724 var sv *types.AudioCodecSettings 5725 if *v == nil { 5726 sv = &types.AudioCodecSettings{} 5727 } else { 5728 sv = *v 5729 } 5730 5731 for key, value := range shape { 5732 switch key { 5733 case "aacSettings": 5734 if err := awsRestjson1_deserializeDocumentAacSettings(&sv.AacSettings, value); err != nil { 5735 return err 5736 } 5737 5738 case "ac3Settings": 5739 if err := awsRestjson1_deserializeDocumentAc3Settings(&sv.Ac3Settings, value); err != nil { 5740 return err 5741 } 5742 5743 case "aiffSettings": 5744 if err := awsRestjson1_deserializeDocumentAiffSettings(&sv.AiffSettings, value); err != nil { 5745 return err 5746 } 5747 5748 case "codec": 5749 if value != nil { 5750 jtv, ok := value.(string) 5751 if !ok { 5752 return fmt.Errorf("expected AudioCodec to be of type string, got %T instead", value) 5753 } 5754 sv.Codec = types.AudioCodec(jtv) 5755 } 5756 5757 case "eac3AtmosSettings": 5758 if err := awsRestjson1_deserializeDocumentEac3AtmosSettings(&sv.Eac3AtmosSettings, value); err != nil { 5759 return err 5760 } 5761 5762 case "eac3Settings": 5763 if err := awsRestjson1_deserializeDocumentEac3Settings(&sv.Eac3Settings, value); err != nil { 5764 return err 5765 } 5766 5767 case "mp2Settings": 5768 if err := awsRestjson1_deserializeDocumentMp2Settings(&sv.Mp2Settings, value); err != nil { 5769 return err 5770 } 5771 5772 case "mp3Settings": 5773 if err := awsRestjson1_deserializeDocumentMp3Settings(&sv.Mp3Settings, value); err != nil { 5774 return err 5775 } 5776 5777 case "opusSettings": 5778 if err := awsRestjson1_deserializeDocumentOpusSettings(&sv.OpusSettings, value); err != nil { 5779 return err 5780 } 5781 5782 case "vorbisSettings": 5783 if err := awsRestjson1_deserializeDocumentVorbisSettings(&sv.VorbisSettings, value); err != nil { 5784 return err 5785 } 5786 5787 case "wavSettings": 5788 if err := awsRestjson1_deserializeDocumentWavSettings(&sv.WavSettings, value); err != nil { 5789 return err 5790 } 5791 5792 default: 5793 _, _ = key, value 5794 5795 } 5796 } 5797 *v = sv 5798 return nil 5799} 5800 5801func awsRestjson1_deserializeDocumentAudioDescription(v **types.AudioDescription, value interface{}) error { 5802 if v == nil { 5803 return fmt.Errorf("unexpected nil of type %T", v) 5804 } 5805 if value == nil { 5806 return nil 5807 } 5808 5809 shape, ok := value.(map[string]interface{}) 5810 if !ok { 5811 return fmt.Errorf("unexpected JSON type %v", value) 5812 } 5813 5814 var sv *types.AudioDescription 5815 if *v == nil { 5816 sv = &types.AudioDescription{} 5817 } else { 5818 sv = *v 5819 } 5820 5821 for key, value := range shape { 5822 switch key { 5823 case "audioChannelTaggingSettings": 5824 if err := awsRestjson1_deserializeDocumentAudioChannelTaggingSettings(&sv.AudioChannelTaggingSettings, value); err != nil { 5825 return err 5826 } 5827 5828 case "audioNormalizationSettings": 5829 if err := awsRestjson1_deserializeDocumentAudioNormalizationSettings(&sv.AudioNormalizationSettings, value); err != nil { 5830 return err 5831 } 5832 5833 case "audioSourceName": 5834 if value != nil { 5835 jtv, ok := value.(string) 5836 if !ok { 5837 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 5838 } 5839 sv.AudioSourceName = ptr.String(jtv) 5840 } 5841 5842 case "audioType": 5843 if value != nil { 5844 jtv, ok := value.(json.Number) 5845 if !ok { 5846 return fmt.Errorf("expected __integerMin0Max255 to be json.Number, got %T instead", value) 5847 } 5848 i64, err := jtv.Int64() 5849 if err != nil { 5850 return err 5851 } 5852 sv.AudioType = int32(i64) 5853 } 5854 5855 case "audioTypeControl": 5856 if value != nil { 5857 jtv, ok := value.(string) 5858 if !ok { 5859 return fmt.Errorf("expected AudioTypeControl to be of type string, got %T instead", value) 5860 } 5861 sv.AudioTypeControl = types.AudioTypeControl(jtv) 5862 } 5863 5864 case "codecSettings": 5865 if err := awsRestjson1_deserializeDocumentAudioCodecSettings(&sv.CodecSettings, value); err != nil { 5866 return err 5867 } 5868 5869 case "customLanguageCode": 5870 if value != nil { 5871 jtv, ok := value.(string) 5872 if !ok { 5873 return fmt.Errorf("expected __stringPatternAZaZ23AZaZ to be of type string, got %T instead", value) 5874 } 5875 sv.CustomLanguageCode = ptr.String(jtv) 5876 } 5877 5878 case "languageCode": 5879 if value != nil { 5880 jtv, ok := value.(string) 5881 if !ok { 5882 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 5883 } 5884 sv.LanguageCode = types.LanguageCode(jtv) 5885 } 5886 5887 case "languageCodeControl": 5888 if value != nil { 5889 jtv, ok := value.(string) 5890 if !ok { 5891 return fmt.Errorf("expected AudioLanguageCodeControl to be of type string, got %T instead", value) 5892 } 5893 sv.LanguageCodeControl = types.AudioLanguageCodeControl(jtv) 5894 } 5895 5896 case "remixSettings": 5897 if err := awsRestjson1_deserializeDocumentRemixSettings(&sv.RemixSettings, value); err != nil { 5898 return err 5899 } 5900 5901 case "streamName": 5902 if value != nil { 5903 jtv, ok := value.(string) 5904 if !ok { 5905 return fmt.Errorf("expected __stringPatternWS to be of type string, got %T instead", value) 5906 } 5907 sv.StreamName = ptr.String(jtv) 5908 } 5909 5910 default: 5911 _, _ = key, value 5912 5913 } 5914 } 5915 *v = sv 5916 return nil 5917} 5918 5919func awsRestjson1_deserializeDocumentAudioNormalizationSettings(v **types.AudioNormalizationSettings, value interface{}) error { 5920 if v == nil { 5921 return fmt.Errorf("unexpected nil of type %T", v) 5922 } 5923 if value == nil { 5924 return nil 5925 } 5926 5927 shape, ok := value.(map[string]interface{}) 5928 if !ok { 5929 return fmt.Errorf("unexpected JSON type %v", value) 5930 } 5931 5932 var sv *types.AudioNormalizationSettings 5933 if *v == nil { 5934 sv = &types.AudioNormalizationSettings{} 5935 } else { 5936 sv = *v 5937 } 5938 5939 for key, value := range shape { 5940 switch key { 5941 case "algorithm": 5942 if value != nil { 5943 jtv, ok := value.(string) 5944 if !ok { 5945 return fmt.Errorf("expected AudioNormalizationAlgorithm to be of type string, got %T instead", value) 5946 } 5947 sv.Algorithm = types.AudioNormalizationAlgorithm(jtv) 5948 } 5949 5950 case "algorithmControl": 5951 if value != nil { 5952 jtv, ok := value.(string) 5953 if !ok { 5954 return fmt.Errorf("expected AudioNormalizationAlgorithmControl to be of type string, got %T instead", value) 5955 } 5956 sv.AlgorithmControl = types.AudioNormalizationAlgorithmControl(jtv) 5957 } 5958 5959 case "correctionGateLevel": 5960 if value != nil { 5961 jtv, ok := value.(json.Number) 5962 if !ok { 5963 return fmt.Errorf("expected __integerMinNegative70Max0 to be json.Number, got %T instead", value) 5964 } 5965 i64, err := jtv.Int64() 5966 if err != nil { 5967 return err 5968 } 5969 sv.CorrectionGateLevel = int32(i64) 5970 } 5971 5972 case "loudnessLogging": 5973 if value != nil { 5974 jtv, ok := value.(string) 5975 if !ok { 5976 return fmt.Errorf("expected AudioNormalizationLoudnessLogging to be of type string, got %T instead", value) 5977 } 5978 sv.LoudnessLogging = types.AudioNormalizationLoudnessLogging(jtv) 5979 } 5980 5981 case "peakCalculation": 5982 if value != nil { 5983 jtv, ok := value.(string) 5984 if !ok { 5985 return fmt.Errorf("expected AudioNormalizationPeakCalculation to be of type string, got %T instead", value) 5986 } 5987 sv.PeakCalculation = types.AudioNormalizationPeakCalculation(jtv) 5988 } 5989 5990 case "targetLkfs": 5991 if value != nil { 5992 switch jtv := value.(type) { 5993 case json.Number: 5994 f64, err := jtv.Float64() 5995 if err != nil { 5996 return err 5997 } 5998 sv.TargetLkfs = f64 5999 6000 case string: 6001 var f64 float64 6002 switch { 6003 case strings.EqualFold(jtv, "NaN"): 6004 f64 = math.NaN() 6005 6006 case strings.EqualFold(jtv, "Infinity"): 6007 f64 = math.Inf(1) 6008 6009 case strings.EqualFold(jtv, "-Infinity"): 6010 f64 = math.Inf(-1) 6011 6012 default: 6013 return fmt.Errorf("unknown JSON number value: %s", jtv) 6014 6015 } 6016 sv.TargetLkfs = f64 6017 6018 default: 6019 return fmt.Errorf("expected __doubleMinNegative59Max0 to be a JSON Number, got %T instead", value) 6020 6021 } 6022 } 6023 6024 default: 6025 _, _ = key, value 6026 6027 } 6028 } 6029 *v = sv 6030 return nil 6031} 6032 6033func awsRestjson1_deserializeDocumentAudioSelector(v **types.AudioSelector, value interface{}) error { 6034 if v == nil { 6035 return fmt.Errorf("unexpected nil of type %T", v) 6036 } 6037 if value == nil { 6038 return nil 6039 } 6040 6041 shape, ok := value.(map[string]interface{}) 6042 if !ok { 6043 return fmt.Errorf("unexpected JSON type %v", value) 6044 } 6045 6046 var sv *types.AudioSelector 6047 if *v == nil { 6048 sv = &types.AudioSelector{} 6049 } else { 6050 sv = *v 6051 } 6052 6053 for key, value := range shape { 6054 switch key { 6055 case "customLanguageCode": 6056 if value != nil { 6057 jtv, ok := value.(string) 6058 if !ok { 6059 return fmt.Errorf("expected __stringMin3Max3PatternAZaZ3 to be of type string, got %T instead", value) 6060 } 6061 sv.CustomLanguageCode = ptr.String(jtv) 6062 } 6063 6064 case "defaultSelection": 6065 if value != nil { 6066 jtv, ok := value.(string) 6067 if !ok { 6068 return fmt.Errorf("expected AudioDefaultSelection to be of type string, got %T instead", value) 6069 } 6070 sv.DefaultSelection = types.AudioDefaultSelection(jtv) 6071 } 6072 6073 case "externalAudioFileInput": 6074 if value != nil { 6075 jtv, ok := value.(string) 6076 if !ok { 6077 return fmt.Errorf("expected __stringPatternS3MM2PPWWEEBBMMMM2VVMMPPEEGGMMPP3AAVVIIMMPP4FFLLVVMMPPTTMMPPGGMM4VVTTRRPPFF4VVMM2TTSSTTSS264HH264MMKKVVMMKKAAMMOOVVMMTTSSMM2TTWWMMVVaAAASSFFVVOOBB3GGPP3GGPPPPMMXXFFDDIIVVXXXXVVIIDDRRAAWWDDVVGGXXFFMM1VV3GG2VVMMFFMM3UU8LLCCHHGGXXFFMMPPEEGG2MMXXFFMMPPEEGG2MMXXFFHHDDWWAAVVYY4MMAAAACCAAIIFFFFMMPP2AACC3EECC3DDTTSSEEAATTMMOOSSHttpsMM2VVMMPPEEGGMMPP3AAVVIIMMPP4FFLLVVMMPPTTMMPPGGMM4VVTTRRPPFF4VVMM2TTSSTTSS264HH264MMKKVVMMKKAAMMOOVVMMTTSSMM2TTWWMMVVaAAASSFFVVOOBB3GGPP3GGPPPPMMXXFFDDIIVVXXXXVVIIDDRRAAWWDDVVGGXXFFMM1VV3GG2VVMMFFMM3UU8LLCCHHGGXXFFMMPPEEGG2MMXXFFMMPPEEGG2MMXXFFHHDDWWAAVVYY4MMAAAACCAAIIFFFFMMPP2AACC3EECC3DDTTSSEEAATTMMOOSS to be of type string, got %T instead", value) 6078 } 6079 sv.ExternalAudioFileInput = ptr.String(jtv) 6080 } 6081 6082 case "hlsRenditionGroupSettings": 6083 if err := awsRestjson1_deserializeDocumentHlsRenditionGroupSettings(&sv.HlsRenditionGroupSettings, value); err != nil { 6084 return err 6085 } 6086 6087 case "languageCode": 6088 if value != nil { 6089 jtv, ok := value.(string) 6090 if !ok { 6091 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 6092 } 6093 sv.LanguageCode = types.LanguageCode(jtv) 6094 } 6095 6096 case "offset": 6097 if value != nil { 6098 jtv, ok := value.(json.Number) 6099 if !ok { 6100 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 6101 } 6102 i64, err := jtv.Int64() 6103 if err != nil { 6104 return err 6105 } 6106 sv.Offset = int32(i64) 6107 } 6108 6109 case "pids": 6110 if err := awsRestjson1_deserializeDocument__listOf__integerMin1Max2147483647(&sv.Pids, value); err != nil { 6111 return err 6112 } 6113 6114 case "programSelection": 6115 if value != nil { 6116 jtv, ok := value.(json.Number) 6117 if !ok { 6118 return fmt.Errorf("expected __integerMin0Max8 to be json.Number, got %T instead", value) 6119 } 6120 i64, err := jtv.Int64() 6121 if err != nil { 6122 return err 6123 } 6124 sv.ProgramSelection = int32(i64) 6125 } 6126 6127 case "remixSettings": 6128 if err := awsRestjson1_deserializeDocumentRemixSettings(&sv.RemixSettings, value); err != nil { 6129 return err 6130 } 6131 6132 case "selectorType": 6133 if value != nil { 6134 jtv, ok := value.(string) 6135 if !ok { 6136 return fmt.Errorf("expected AudioSelectorType to be of type string, got %T instead", value) 6137 } 6138 sv.SelectorType = types.AudioSelectorType(jtv) 6139 } 6140 6141 case "tracks": 6142 if err := awsRestjson1_deserializeDocument__listOf__integerMin1Max2147483647(&sv.Tracks, value); err != nil { 6143 return err 6144 } 6145 6146 default: 6147 _, _ = key, value 6148 6149 } 6150 } 6151 *v = sv 6152 return nil 6153} 6154 6155func awsRestjson1_deserializeDocumentAudioSelectorGroup(v **types.AudioSelectorGroup, value interface{}) error { 6156 if v == nil { 6157 return fmt.Errorf("unexpected nil of type %T", v) 6158 } 6159 if value == nil { 6160 return nil 6161 } 6162 6163 shape, ok := value.(map[string]interface{}) 6164 if !ok { 6165 return fmt.Errorf("unexpected JSON type %v", value) 6166 } 6167 6168 var sv *types.AudioSelectorGroup 6169 if *v == nil { 6170 sv = &types.AudioSelectorGroup{} 6171 } else { 6172 sv = *v 6173 } 6174 6175 for key, value := range shape { 6176 switch key { 6177 case "audioSelectorNames": 6178 if err := awsRestjson1_deserializeDocument__listOf__stringMin1(&sv.AudioSelectorNames, value); err != nil { 6179 return err 6180 } 6181 6182 default: 6183 _, _ = key, value 6184 6185 } 6186 } 6187 *v = sv 6188 return nil 6189} 6190 6191func awsRestjson1_deserializeDocumentAutomatedAbrSettings(v **types.AutomatedAbrSettings, value interface{}) error { 6192 if v == nil { 6193 return fmt.Errorf("unexpected nil of type %T", v) 6194 } 6195 if value == nil { 6196 return nil 6197 } 6198 6199 shape, ok := value.(map[string]interface{}) 6200 if !ok { 6201 return fmt.Errorf("unexpected JSON type %v", value) 6202 } 6203 6204 var sv *types.AutomatedAbrSettings 6205 if *v == nil { 6206 sv = &types.AutomatedAbrSettings{} 6207 } else { 6208 sv = *v 6209 } 6210 6211 for key, value := range shape { 6212 switch key { 6213 case "maxAbrBitrate": 6214 if value != nil { 6215 jtv, ok := value.(json.Number) 6216 if !ok { 6217 return fmt.Errorf("expected __integerMin100000Max100000000 to be json.Number, got %T instead", value) 6218 } 6219 i64, err := jtv.Int64() 6220 if err != nil { 6221 return err 6222 } 6223 sv.MaxAbrBitrate = int32(i64) 6224 } 6225 6226 case "maxRenditions": 6227 if value != nil { 6228 jtv, ok := value.(json.Number) 6229 if !ok { 6230 return fmt.Errorf("expected __integerMin3Max15 to be json.Number, got %T instead", value) 6231 } 6232 i64, err := jtv.Int64() 6233 if err != nil { 6234 return err 6235 } 6236 sv.MaxRenditions = int32(i64) 6237 } 6238 6239 case "minAbrBitrate": 6240 if value != nil { 6241 jtv, ok := value.(json.Number) 6242 if !ok { 6243 return fmt.Errorf("expected __integerMin100000Max100000000 to be json.Number, got %T instead", value) 6244 } 6245 i64, err := jtv.Int64() 6246 if err != nil { 6247 return err 6248 } 6249 sv.MinAbrBitrate = int32(i64) 6250 } 6251 6252 default: 6253 _, _ = key, value 6254 6255 } 6256 } 6257 *v = sv 6258 return nil 6259} 6260 6261func awsRestjson1_deserializeDocumentAutomatedEncodingSettings(v **types.AutomatedEncodingSettings, value interface{}) error { 6262 if v == nil { 6263 return fmt.Errorf("unexpected nil of type %T", v) 6264 } 6265 if value == nil { 6266 return nil 6267 } 6268 6269 shape, ok := value.(map[string]interface{}) 6270 if !ok { 6271 return fmt.Errorf("unexpected JSON type %v", value) 6272 } 6273 6274 var sv *types.AutomatedEncodingSettings 6275 if *v == nil { 6276 sv = &types.AutomatedEncodingSettings{} 6277 } else { 6278 sv = *v 6279 } 6280 6281 for key, value := range shape { 6282 switch key { 6283 case "abrSettings": 6284 if err := awsRestjson1_deserializeDocumentAutomatedAbrSettings(&sv.AbrSettings, value); err != nil { 6285 return err 6286 } 6287 6288 default: 6289 _, _ = key, value 6290 6291 } 6292 } 6293 *v = sv 6294 return nil 6295} 6296 6297func awsRestjson1_deserializeDocumentAv1QvbrSettings(v **types.Av1QvbrSettings, value interface{}) error { 6298 if v == nil { 6299 return fmt.Errorf("unexpected nil of type %T", v) 6300 } 6301 if value == nil { 6302 return nil 6303 } 6304 6305 shape, ok := value.(map[string]interface{}) 6306 if !ok { 6307 return fmt.Errorf("unexpected JSON type %v", value) 6308 } 6309 6310 var sv *types.Av1QvbrSettings 6311 if *v == nil { 6312 sv = &types.Av1QvbrSettings{} 6313 } else { 6314 sv = *v 6315 } 6316 6317 for key, value := range shape { 6318 switch key { 6319 case "qvbrQualityLevel": 6320 if value != nil { 6321 jtv, ok := value.(json.Number) 6322 if !ok { 6323 return fmt.Errorf("expected __integerMin1Max10 to be json.Number, got %T instead", value) 6324 } 6325 i64, err := jtv.Int64() 6326 if err != nil { 6327 return err 6328 } 6329 sv.QvbrQualityLevel = int32(i64) 6330 } 6331 6332 case "qvbrQualityLevelFineTune": 6333 if value != nil { 6334 switch jtv := value.(type) { 6335 case json.Number: 6336 f64, err := jtv.Float64() 6337 if err != nil { 6338 return err 6339 } 6340 sv.QvbrQualityLevelFineTune = f64 6341 6342 case string: 6343 var f64 float64 6344 switch { 6345 case strings.EqualFold(jtv, "NaN"): 6346 f64 = math.NaN() 6347 6348 case strings.EqualFold(jtv, "Infinity"): 6349 f64 = math.Inf(1) 6350 6351 case strings.EqualFold(jtv, "-Infinity"): 6352 f64 = math.Inf(-1) 6353 6354 default: 6355 return fmt.Errorf("unknown JSON number value: %s", jtv) 6356 6357 } 6358 sv.QvbrQualityLevelFineTune = f64 6359 6360 default: 6361 return fmt.Errorf("expected __doubleMin0Max1 to be a JSON Number, got %T instead", value) 6362 6363 } 6364 } 6365 6366 default: 6367 _, _ = key, value 6368 6369 } 6370 } 6371 *v = sv 6372 return nil 6373} 6374 6375func awsRestjson1_deserializeDocumentAv1Settings(v **types.Av1Settings, value interface{}) error { 6376 if v == nil { 6377 return fmt.Errorf("unexpected nil of type %T", v) 6378 } 6379 if value == nil { 6380 return nil 6381 } 6382 6383 shape, ok := value.(map[string]interface{}) 6384 if !ok { 6385 return fmt.Errorf("unexpected JSON type %v", value) 6386 } 6387 6388 var sv *types.Av1Settings 6389 if *v == nil { 6390 sv = &types.Av1Settings{} 6391 } else { 6392 sv = *v 6393 } 6394 6395 for key, value := range shape { 6396 switch key { 6397 case "adaptiveQuantization": 6398 if value != nil { 6399 jtv, ok := value.(string) 6400 if !ok { 6401 return fmt.Errorf("expected Av1AdaptiveQuantization to be of type string, got %T instead", value) 6402 } 6403 sv.AdaptiveQuantization = types.Av1AdaptiveQuantization(jtv) 6404 } 6405 6406 case "framerateControl": 6407 if value != nil { 6408 jtv, ok := value.(string) 6409 if !ok { 6410 return fmt.Errorf("expected Av1FramerateControl to be of type string, got %T instead", value) 6411 } 6412 sv.FramerateControl = types.Av1FramerateControl(jtv) 6413 } 6414 6415 case "framerateConversionAlgorithm": 6416 if value != nil { 6417 jtv, ok := value.(string) 6418 if !ok { 6419 return fmt.Errorf("expected Av1FramerateConversionAlgorithm to be of type string, got %T instead", value) 6420 } 6421 sv.FramerateConversionAlgorithm = types.Av1FramerateConversionAlgorithm(jtv) 6422 } 6423 6424 case "framerateDenominator": 6425 if value != nil { 6426 jtv, ok := value.(json.Number) 6427 if !ok { 6428 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 6429 } 6430 i64, err := jtv.Int64() 6431 if err != nil { 6432 return err 6433 } 6434 sv.FramerateDenominator = int32(i64) 6435 } 6436 6437 case "framerateNumerator": 6438 if value != nil { 6439 jtv, ok := value.(json.Number) 6440 if !ok { 6441 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 6442 } 6443 i64, err := jtv.Int64() 6444 if err != nil { 6445 return err 6446 } 6447 sv.FramerateNumerator = int32(i64) 6448 } 6449 6450 case "gopSize": 6451 if value != nil { 6452 switch jtv := value.(type) { 6453 case json.Number: 6454 f64, err := jtv.Float64() 6455 if err != nil { 6456 return err 6457 } 6458 sv.GopSize = f64 6459 6460 case string: 6461 var f64 float64 6462 switch { 6463 case strings.EqualFold(jtv, "NaN"): 6464 f64 = math.NaN() 6465 6466 case strings.EqualFold(jtv, "Infinity"): 6467 f64 = math.Inf(1) 6468 6469 case strings.EqualFold(jtv, "-Infinity"): 6470 f64 = math.Inf(-1) 6471 6472 default: 6473 return fmt.Errorf("unknown JSON number value: %s", jtv) 6474 6475 } 6476 sv.GopSize = f64 6477 6478 default: 6479 return fmt.Errorf("expected __doubleMin0 to be a JSON Number, got %T instead", value) 6480 6481 } 6482 } 6483 6484 case "maxBitrate": 6485 if value != nil { 6486 jtv, ok := value.(json.Number) 6487 if !ok { 6488 return fmt.Errorf("expected __integerMin1000Max1152000000 to be json.Number, got %T instead", value) 6489 } 6490 i64, err := jtv.Int64() 6491 if err != nil { 6492 return err 6493 } 6494 sv.MaxBitrate = int32(i64) 6495 } 6496 6497 case "numberBFramesBetweenReferenceFrames": 6498 if value != nil { 6499 jtv, ok := value.(json.Number) 6500 if !ok { 6501 return fmt.Errorf("expected __integerMin0Max15 to be json.Number, got %T instead", value) 6502 } 6503 i64, err := jtv.Int64() 6504 if err != nil { 6505 return err 6506 } 6507 sv.NumberBFramesBetweenReferenceFrames = int32(i64) 6508 } 6509 6510 case "qvbrSettings": 6511 if err := awsRestjson1_deserializeDocumentAv1QvbrSettings(&sv.QvbrSettings, value); err != nil { 6512 return err 6513 } 6514 6515 case "rateControlMode": 6516 if value != nil { 6517 jtv, ok := value.(string) 6518 if !ok { 6519 return fmt.Errorf("expected Av1RateControlMode to be of type string, got %T instead", value) 6520 } 6521 sv.RateControlMode = types.Av1RateControlMode(jtv) 6522 } 6523 6524 case "slices": 6525 if value != nil { 6526 jtv, ok := value.(json.Number) 6527 if !ok { 6528 return fmt.Errorf("expected __integerMin1Max32 to be json.Number, got %T instead", value) 6529 } 6530 i64, err := jtv.Int64() 6531 if err != nil { 6532 return err 6533 } 6534 sv.Slices = int32(i64) 6535 } 6536 6537 case "spatialAdaptiveQuantization": 6538 if value != nil { 6539 jtv, ok := value.(string) 6540 if !ok { 6541 return fmt.Errorf("expected Av1SpatialAdaptiveQuantization to be of type string, got %T instead", value) 6542 } 6543 sv.SpatialAdaptiveQuantization = types.Av1SpatialAdaptiveQuantization(jtv) 6544 } 6545 6546 default: 6547 _, _ = key, value 6548 6549 } 6550 } 6551 *v = sv 6552 return nil 6553} 6554 6555func awsRestjson1_deserializeDocumentAvailBlanking(v **types.AvailBlanking, value interface{}) error { 6556 if v == nil { 6557 return fmt.Errorf("unexpected nil of type %T", v) 6558 } 6559 if value == nil { 6560 return nil 6561 } 6562 6563 shape, ok := value.(map[string]interface{}) 6564 if !ok { 6565 return fmt.Errorf("unexpected JSON type %v", value) 6566 } 6567 6568 var sv *types.AvailBlanking 6569 if *v == nil { 6570 sv = &types.AvailBlanking{} 6571 } else { 6572 sv = *v 6573 } 6574 6575 for key, value := range shape { 6576 switch key { 6577 case "availBlankingImage": 6578 if value != nil { 6579 jtv, ok := value.(string) 6580 if !ok { 6581 return fmt.Errorf("expected __stringMin14PatternS3BmpBMPPngPNGHttpsBmpBMPPngPNG to be of type string, got %T instead", value) 6582 } 6583 sv.AvailBlankingImage = ptr.String(jtv) 6584 } 6585 6586 default: 6587 _, _ = key, value 6588 6589 } 6590 } 6591 *v = sv 6592 return nil 6593} 6594 6595func awsRestjson1_deserializeDocumentAvcIntraSettings(v **types.AvcIntraSettings, value interface{}) error { 6596 if v == nil { 6597 return fmt.Errorf("unexpected nil of type %T", v) 6598 } 6599 if value == nil { 6600 return nil 6601 } 6602 6603 shape, ok := value.(map[string]interface{}) 6604 if !ok { 6605 return fmt.Errorf("unexpected JSON type %v", value) 6606 } 6607 6608 var sv *types.AvcIntraSettings 6609 if *v == nil { 6610 sv = &types.AvcIntraSettings{} 6611 } else { 6612 sv = *v 6613 } 6614 6615 for key, value := range shape { 6616 switch key { 6617 case "avcIntraClass": 6618 if value != nil { 6619 jtv, ok := value.(string) 6620 if !ok { 6621 return fmt.Errorf("expected AvcIntraClass to be of type string, got %T instead", value) 6622 } 6623 sv.AvcIntraClass = types.AvcIntraClass(jtv) 6624 } 6625 6626 case "avcIntraUhdSettings": 6627 if err := awsRestjson1_deserializeDocumentAvcIntraUhdSettings(&sv.AvcIntraUhdSettings, value); err != nil { 6628 return err 6629 } 6630 6631 case "framerateControl": 6632 if value != nil { 6633 jtv, ok := value.(string) 6634 if !ok { 6635 return fmt.Errorf("expected AvcIntraFramerateControl to be of type string, got %T instead", value) 6636 } 6637 sv.FramerateControl = types.AvcIntraFramerateControl(jtv) 6638 } 6639 6640 case "framerateConversionAlgorithm": 6641 if value != nil { 6642 jtv, ok := value.(string) 6643 if !ok { 6644 return fmt.Errorf("expected AvcIntraFramerateConversionAlgorithm to be of type string, got %T instead", value) 6645 } 6646 sv.FramerateConversionAlgorithm = types.AvcIntraFramerateConversionAlgorithm(jtv) 6647 } 6648 6649 case "framerateDenominator": 6650 if value != nil { 6651 jtv, ok := value.(json.Number) 6652 if !ok { 6653 return fmt.Errorf("expected __integerMin1Max1001 to be json.Number, got %T instead", value) 6654 } 6655 i64, err := jtv.Int64() 6656 if err != nil { 6657 return err 6658 } 6659 sv.FramerateDenominator = int32(i64) 6660 } 6661 6662 case "framerateNumerator": 6663 if value != nil { 6664 jtv, ok := value.(json.Number) 6665 if !ok { 6666 return fmt.Errorf("expected __integerMin24Max60000 to be json.Number, got %T instead", value) 6667 } 6668 i64, err := jtv.Int64() 6669 if err != nil { 6670 return err 6671 } 6672 sv.FramerateNumerator = int32(i64) 6673 } 6674 6675 case "interlaceMode": 6676 if value != nil { 6677 jtv, ok := value.(string) 6678 if !ok { 6679 return fmt.Errorf("expected AvcIntraInterlaceMode to be of type string, got %T instead", value) 6680 } 6681 sv.InterlaceMode = types.AvcIntraInterlaceMode(jtv) 6682 } 6683 6684 case "scanTypeConversionMode": 6685 if value != nil { 6686 jtv, ok := value.(string) 6687 if !ok { 6688 return fmt.Errorf("expected AvcIntraScanTypeConversionMode to be of type string, got %T instead", value) 6689 } 6690 sv.ScanTypeConversionMode = types.AvcIntraScanTypeConversionMode(jtv) 6691 } 6692 6693 case "slowPal": 6694 if value != nil { 6695 jtv, ok := value.(string) 6696 if !ok { 6697 return fmt.Errorf("expected AvcIntraSlowPal to be of type string, got %T instead", value) 6698 } 6699 sv.SlowPal = types.AvcIntraSlowPal(jtv) 6700 } 6701 6702 case "telecine": 6703 if value != nil { 6704 jtv, ok := value.(string) 6705 if !ok { 6706 return fmt.Errorf("expected AvcIntraTelecine to be of type string, got %T instead", value) 6707 } 6708 sv.Telecine = types.AvcIntraTelecine(jtv) 6709 } 6710 6711 default: 6712 _, _ = key, value 6713 6714 } 6715 } 6716 *v = sv 6717 return nil 6718} 6719 6720func awsRestjson1_deserializeDocumentAvcIntraUhdSettings(v **types.AvcIntraUhdSettings, value interface{}) error { 6721 if v == nil { 6722 return fmt.Errorf("unexpected nil of type %T", v) 6723 } 6724 if value == nil { 6725 return nil 6726 } 6727 6728 shape, ok := value.(map[string]interface{}) 6729 if !ok { 6730 return fmt.Errorf("unexpected JSON type %v", value) 6731 } 6732 6733 var sv *types.AvcIntraUhdSettings 6734 if *v == nil { 6735 sv = &types.AvcIntraUhdSettings{} 6736 } else { 6737 sv = *v 6738 } 6739 6740 for key, value := range shape { 6741 switch key { 6742 case "qualityTuningLevel": 6743 if value != nil { 6744 jtv, ok := value.(string) 6745 if !ok { 6746 return fmt.Errorf("expected AvcIntraUhdQualityTuningLevel to be of type string, got %T instead", value) 6747 } 6748 sv.QualityTuningLevel = types.AvcIntraUhdQualityTuningLevel(jtv) 6749 } 6750 6751 default: 6752 _, _ = key, value 6753 6754 } 6755 } 6756 *v = sv 6757 return nil 6758} 6759 6760func awsRestjson1_deserializeDocumentBadRequestException(v **types.BadRequestException, value interface{}) error { 6761 if v == nil { 6762 return fmt.Errorf("unexpected nil of type %T", v) 6763 } 6764 if value == nil { 6765 return nil 6766 } 6767 6768 shape, ok := value.(map[string]interface{}) 6769 if !ok { 6770 return fmt.Errorf("unexpected JSON type %v", value) 6771 } 6772 6773 var sv *types.BadRequestException 6774 if *v == nil { 6775 sv = &types.BadRequestException{} 6776 } else { 6777 sv = *v 6778 } 6779 6780 for key, value := range shape { 6781 switch key { 6782 case "message": 6783 if value != nil { 6784 jtv, ok := value.(string) 6785 if !ok { 6786 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 6787 } 6788 sv.Message = ptr.String(jtv) 6789 } 6790 6791 default: 6792 _, _ = key, value 6793 6794 } 6795 } 6796 *v = sv 6797 return nil 6798} 6799 6800func awsRestjson1_deserializeDocumentBurninDestinationSettings(v **types.BurninDestinationSettings, value interface{}) error { 6801 if v == nil { 6802 return fmt.Errorf("unexpected nil of type %T", v) 6803 } 6804 if value == nil { 6805 return nil 6806 } 6807 6808 shape, ok := value.(map[string]interface{}) 6809 if !ok { 6810 return fmt.Errorf("unexpected JSON type %v", value) 6811 } 6812 6813 var sv *types.BurninDestinationSettings 6814 if *v == nil { 6815 sv = &types.BurninDestinationSettings{} 6816 } else { 6817 sv = *v 6818 } 6819 6820 for key, value := range shape { 6821 switch key { 6822 case "alignment": 6823 if value != nil { 6824 jtv, ok := value.(string) 6825 if !ok { 6826 return fmt.Errorf("expected BurninSubtitleAlignment to be of type string, got %T instead", value) 6827 } 6828 sv.Alignment = types.BurninSubtitleAlignment(jtv) 6829 } 6830 6831 case "backgroundColor": 6832 if value != nil { 6833 jtv, ok := value.(string) 6834 if !ok { 6835 return fmt.Errorf("expected BurninSubtitleBackgroundColor to be of type string, got %T instead", value) 6836 } 6837 sv.BackgroundColor = types.BurninSubtitleBackgroundColor(jtv) 6838 } 6839 6840 case "backgroundOpacity": 6841 if value != nil { 6842 jtv, ok := value.(json.Number) 6843 if !ok { 6844 return fmt.Errorf("expected __integerMin0Max255 to be json.Number, got %T instead", value) 6845 } 6846 i64, err := jtv.Int64() 6847 if err != nil { 6848 return err 6849 } 6850 sv.BackgroundOpacity = int32(i64) 6851 } 6852 6853 case "fontColor": 6854 if value != nil { 6855 jtv, ok := value.(string) 6856 if !ok { 6857 return fmt.Errorf("expected BurninSubtitleFontColor to be of type string, got %T instead", value) 6858 } 6859 sv.FontColor = types.BurninSubtitleFontColor(jtv) 6860 } 6861 6862 case "fontOpacity": 6863 if value != nil { 6864 jtv, ok := value.(json.Number) 6865 if !ok { 6866 return fmt.Errorf("expected __integerMin0Max255 to be json.Number, got %T instead", value) 6867 } 6868 i64, err := jtv.Int64() 6869 if err != nil { 6870 return err 6871 } 6872 sv.FontOpacity = int32(i64) 6873 } 6874 6875 case "fontResolution": 6876 if value != nil { 6877 jtv, ok := value.(json.Number) 6878 if !ok { 6879 return fmt.Errorf("expected __integerMin96Max600 to be json.Number, got %T instead", value) 6880 } 6881 i64, err := jtv.Int64() 6882 if err != nil { 6883 return err 6884 } 6885 sv.FontResolution = int32(i64) 6886 } 6887 6888 case "fontScript": 6889 if value != nil { 6890 jtv, ok := value.(string) 6891 if !ok { 6892 return fmt.Errorf("expected FontScript to be of type string, got %T instead", value) 6893 } 6894 sv.FontScript = types.FontScript(jtv) 6895 } 6896 6897 case "fontSize": 6898 if value != nil { 6899 jtv, ok := value.(json.Number) 6900 if !ok { 6901 return fmt.Errorf("expected __integerMin0Max96 to be json.Number, got %T instead", value) 6902 } 6903 i64, err := jtv.Int64() 6904 if err != nil { 6905 return err 6906 } 6907 sv.FontSize = int32(i64) 6908 } 6909 6910 case "outlineColor": 6911 if value != nil { 6912 jtv, ok := value.(string) 6913 if !ok { 6914 return fmt.Errorf("expected BurninSubtitleOutlineColor to be of type string, got %T instead", value) 6915 } 6916 sv.OutlineColor = types.BurninSubtitleOutlineColor(jtv) 6917 } 6918 6919 case "outlineSize": 6920 if value != nil { 6921 jtv, ok := value.(json.Number) 6922 if !ok { 6923 return fmt.Errorf("expected __integerMin0Max10 to be json.Number, got %T instead", value) 6924 } 6925 i64, err := jtv.Int64() 6926 if err != nil { 6927 return err 6928 } 6929 sv.OutlineSize = int32(i64) 6930 } 6931 6932 case "shadowColor": 6933 if value != nil { 6934 jtv, ok := value.(string) 6935 if !ok { 6936 return fmt.Errorf("expected BurninSubtitleShadowColor to be of type string, got %T instead", value) 6937 } 6938 sv.ShadowColor = types.BurninSubtitleShadowColor(jtv) 6939 } 6940 6941 case "shadowOpacity": 6942 if value != nil { 6943 jtv, ok := value.(json.Number) 6944 if !ok { 6945 return fmt.Errorf("expected __integerMin0Max255 to be json.Number, got %T instead", value) 6946 } 6947 i64, err := jtv.Int64() 6948 if err != nil { 6949 return err 6950 } 6951 sv.ShadowOpacity = int32(i64) 6952 } 6953 6954 case "shadowXOffset": 6955 if value != nil { 6956 jtv, ok := value.(json.Number) 6957 if !ok { 6958 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 6959 } 6960 i64, err := jtv.Int64() 6961 if err != nil { 6962 return err 6963 } 6964 sv.ShadowXOffset = int32(i64) 6965 } 6966 6967 case "shadowYOffset": 6968 if value != nil { 6969 jtv, ok := value.(json.Number) 6970 if !ok { 6971 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 6972 } 6973 i64, err := jtv.Int64() 6974 if err != nil { 6975 return err 6976 } 6977 sv.ShadowYOffset = int32(i64) 6978 } 6979 6980 case "teletextSpacing": 6981 if value != nil { 6982 jtv, ok := value.(string) 6983 if !ok { 6984 return fmt.Errorf("expected BurninSubtitleTeletextSpacing to be of type string, got %T instead", value) 6985 } 6986 sv.TeletextSpacing = types.BurninSubtitleTeletextSpacing(jtv) 6987 } 6988 6989 case "xPosition": 6990 if value != nil { 6991 jtv, ok := value.(json.Number) 6992 if !ok { 6993 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 6994 } 6995 i64, err := jtv.Int64() 6996 if err != nil { 6997 return err 6998 } 6999 sv.XPosition = int32(i64) 7000 } 7001 7002 case "yPosition": 7003 if value != nil { 7004 jtv, ok := value.(json.Number) 7005 if !ok { 7006 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 7007 } 7008 i64, err := jtv.Int64() 7009 if err != nil { 7010 return err 7011 } 7012 sv.YPosition = int32(i64) 7013 } 7014 7015 default: 7016 _, _ = key, value 7017 7018 } 7019 } 7020 *v = sv 7021 return nil 7022} 7023 7024func awsRestjson1_deserializeDocumentCaptionDescription(v **types.CaptionDescription, value interface{}) error { 7025 if v == nil { 7026 return fmt.Errorf("unexpected nil of type %T", v) 7027 } 7028 if value == nil { 7029 return nil 7030 } 7031 7032 shape, ok := value.(map[string]interface{}) 7033 if !ok { 7034 return fmt.Errorf("unexpected JSON type %v", value) 7035 } 7036 7037 var sv *types.CaptionDescription 7038 if *v == nil { 7039 sv = &types.CaptionDescription{} 7040 } else { 7041 sv = *v 7042 } 7043 7044 for key, value := range shape { 7045 switch key { 7046 case "captionSelectorName": 7047 if value != nil { 7048 jtv, ok := value.(string) 7049 if !ok { 7050 return fmt.Errorf("expected __stringMin1 to be of type string, got %T instead", value) 7051 } 7052 sv.CaptionSelectorName = ptr.String(jtv) 7053 } 7054 7055 case "customLanguageCode": 7056 if value != nil { 7057 jtv, ok := value.(string) 7058 if !ok { 7059 return fmt.Errorf("expected __stringPatternAZaZ23AZaZ to be of type string, got %T instead", value) 7060 } 7061 sv.CustomLanguageCode = ptr.String(jtv) 7062 } 7063 7064 case "destinationSettings": 7065 if err := awsRestjson1_deserializeDocumentCaptionDestinationSettings(&sv.DestinationSettings, value); err != nil { 7066 return err 7067 } 7068 7069 case "languageCode": 7070 if value != nil { 7071 jtv, ok := value.(string) 7072 if !ok { 7073 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 7074 } 7075 sv.LanguageCode = types.LanguageCode(jtv) 7076 } 7077 7078 case "languageDescription": 7079 if value != nil { 7080 jtv, ok := value.(string) 7081 if !ok { 7082 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 7083 } 7084 sv.LanguageDescription = ptr.String(jtv) 7085 } 7086 7087 default: 7088 _, _ = key, value 7089 7090 } 7091 } 7092 *v = sv 7093 return nil 7094} 7095 7096func awsRestjson1_deserializeDocumentCaptionDescriptionPreset(v **types.CaptionDescriptionPreset, value interface{}) error { 7097 if v == nil { 7098 return fmt.Errorf("unexpected nil of type %T", v) 7099 } 7100 if value == nil { 7101 return nil 7102 } 7103 7104 shape, ok := value.(map[string]interface{}) 7105 if !ok { 7106 return fmt.Errorf("unexpected JSON type %v", value) 7107 } 7108 7109 var sv *types.CaptionDescriptionPreset 7110 if *v == nil { 7111 sv = &types.CaptionDescriptionPreset{} 7112 } else { 7113 sv = *v 7114 } 7115 7116 for key, value := range shape { 7117 switch key { 7118 case "customLanguageCode": 7119 if value != nil { 7120 jtv, ok := value.(string) 7121 if !ok { 7122 return fmt.Errorf("expected __stringPatternAZaZ23AZaZ to be of type string, got %T instead", value) 7123 } 7124 sv.CustomLanguageCode = ptr.String(jtv) 7125 } 7126 7127 case "destinationSettings": 7128 if err := awsRestjson1_deserializeDocumentCaptionDestinationSettings(&sv.DestinationSettings, value); err != nil { 7129 return err 7130 } 7131 7132 case "languageCode": 7133 if value != nil { 7134 jtv, ok := value.(string) 7135 if !ok { 7136 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 7137 } 7138 sv.LanguageCode = types.LanguageCode(jtv) 7139 } 7140 7141 case "languageDescription": 7142 if value != nil { 7143 jtv, ok := value.(string) 7144 if !ok { 7145 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 7146 } 7147 sv.LanguageDescription = ptr.String(jtv) 7148 } 7149 7150 default: 7151 _, _ = key, value 7152 7153 } 7154 } 7155 *v = sv 7156 return nil 7157} 7158 7159func awsRestjson1_deserializeDocumentCaptionDestinationSettings(v **types.CaptionDestinationSettings, value interface{}) error { 7160 if v == nil { 7161 return fmt.Errorf("unexpected nil of type %T", v) 7162 } 7163 if value == nil { 7164 return nil 7165 } 7166 7167 shape, ok := value.(map[string]interface{}) 7168 if !ok { 7169 return fmt.Errorf("unexpected JSON type %v", value) 7170 } 7171 7172 var sv *types.CaptionDestinationSettings 7173 if *v == nil { 7174 sv = &types.CaptionDestinationSettings{} 7175 } else { 7176 sv = *v 7177 } 7178 7179 for key, value := range shape { 7180 switch key { 7181 case "burninDestinationSettings": 7182 if err := awsRestjson1_deserializeDocumentBurninDestinationSettings(&sv.BurninDestinationSettings, value); err != nil { 7183 return err 7184 } 7185 7186 case "destinationType": 7187 if value != nil { 7188 jtv, ok := value.(string) 7189 if !ok { 7190 return fmt.Errorf("expected CaptionDestinationType to be of type string, got %T instead", value) 7191 } 7192 sv.DestinationType = types.CaptionDestinationType(jtv) 7193 } 7194 7195 case "dvbSubDestinationSettings": 7196 if err := awsRestjson1_deserializeDocumentDvbSubDestinationSettings(&sv.DvbSubDestinationSettings, value); err != nil { 7197 return err 7198 } 7199 7200 case "embeddedDestinationSettings": 7201 if err := awsRestjson1_deserializeDocumentEmbeddedDestinationSettings(&sv.EmbeddedDestinationSettings, value); err != nil { 7202 return err 7203 } 7204 7205 case "imscDestinationSettings": 7206 if err := awsRestjson1_deserializeDocumentImscDestinationSettings(&sv.ImscDestinationSettings, value); err != nil { 7207 return err 7208 } 7209 7210 case "sccDestinationSettings": 7211 if err := awsRestjson1_deserializeDocumentSccDestinationSettings(&sv.SccDestinationSettings, value); err != nil { 7212 return err 7213 } 7214 7215 case "srtDestinationSettings": 7216 if err := awsRestjson1_deserializeDocumentSrtDestinationSettings(&sv.SrtDestinationSettings, value); err != nil { 7217 return err 7218 } 7219 7220 case "teletextDestinationSettings": 7221 if err := awsRestjson1_deserializeDocumentTeletextDestinationSettings(&sv.TeletextDestinationSettings, value); err != nil { 7222 return err 7223 } 7224 7225 case "ttmlDestinationSettings": 7226 if err := awsRestjson1_deserializeDocumentTtmlDestinationSettings(&sv.TtmlDestinationSettings, value); err != nil { 7227 return err 7228 } 7229 7230 case "webvttDestinationSettings": 7231 if err := awsRestjson1_deserializeDocumentWebvttDestinationSettings(&sv.WebvttDestinationSettings, value); err != nil { 7232 return err 7233 } 7234 7235 default: 7236 _, _ = key, value 7237 7238 } 7239 } 7240 *v = sv 7241 return nil 7242} 7243 7244func awsRestjson1_deserializeDocumentCaptionSelector(v **types.CaptionSelector, value interface{}) error { 7245 if v == nil { 7246 return fmt.Errorf("unexpected nil of type %T", v) 7247 } 7248 if value == nil { 7249 return nil 7250 } 7251 7252 shape, ok := value.(map[string]interface{}) 7253 if !ok { 7254 return fmt.Errorf("unexpected JSON type %v", value) 7255 } 7256 7257 var sv *types.CaptionSelector 7258 if *v == nil { 7259 sv = &types.CaptionSelector{} 7260 } else { 7261 sv = *v 7262 } 7263 7264 for key, value := range shape { 7265 switch key { 7266 case "customLanguageCode": 7267 if value != nil { 7268 jtv, ok := value.(string) 7269 if !ok { 7270 return fmt.Errorf("expected __stringMin3Max3PatternAZaZ3 to be of type string, got %T instead", value) 7271 } 7272 sv.CustomLanguageCode = ptr.String(jtv) 7273 } 7274 7275 case "languageCode": 7276 if value != nil { 7277 jtv, ok := value.(string) 7278 if !ok { 7279 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 7280 } 7281 sv.LanguageCode = types.LanguageCode(jtv) 7282 } 7283 7284 case "sourceSettings": 7285 if err := awsRestjson1_deserializeDocumentCaptionSourceSettings(&sv.SourceSettings, value); err != nil { 7286 return err 7287 } 7288 7289 default: 7290 _, _ = key, value 7291 7292 } 7293 } 7294 *v = sv 7295 return nil 7296} 7297 7298func awsRestjson1_deserializeDocumentCaptionSourceFramerate(v **types.CaptionSourceFramerate, value interface{}) error { 7299 if v == nil { 7300 return fmt.Errorf("unexpected nil of type %T", v) 7301 } 7302 if value == nil { 7303 return nil 7304 } 7305 7306 shape, ok := value.(map[string]interface{}) 7307 if !ok { 7308 return fmt.Errorf("unexpected JSON type %v", value) 7309 } 7310 7311 var sv *types.CaptionSourceFramerate 7312 if *v == nil { 7313 sv = &types.CaptionSourceFramerate{} 7314 } else { 7315 sv = *v 7316 } 7317 7318 for key, value := range shape { 7319 switch key { 7320 case "framerateDenominator": 7321 if value != nil { 7322 jtv, ok := value.(json.Number) 7323 if !ok { 7324 return fmt.Errorf("expected __integerMin1Max1001 to be json.Number, got %T instead", value) 7325 } 7326 i64, err := jtv.Int64() 7327 if err != nil { 7328 return err 7329 } 7330 sv.FramerateDenominator = int32(i64) 7331 } 7332 7333 case "framerateNumerator": 7334 if value != nil { 7335 jtv, ok := value.(json.Number) 7336 if !ok { 7337 return fmt.Errorf("expected __integerMin1Max60000 to be json.Number, got %T instead", value) 7338 } 7339 i64, err := jtv.Int64() 7340 if err != nil { 7341 return err 7342 } 7343 sv.FramerateNumerator = int32(i64) 7344 } 7345 7346 default: 7347 _, _ = key, value 7348 7349 } 7350 } 7351 *v = sv 7352 return nil 7353} 7354 7355func awsRestjson1_deserializeDocumentCaptionSourceSettings(v **types.CaptionSourceSettings, value interface{}) error { 7356 if v == nil { 7357 return fmt.Errorf("unexpected nil of type %T", v) 7358 } 7359 if value == nil { 7360 return nil 7361 } 7362 7363 shape, ok := value.(map[string]interface{}) 7364 if !ok { 7365 return fmt.Errorf("unexpected JSON type %v", value) 7366 } 7367 7368 var sv *types.CaptionSourceSettings 7369 if *v == nil { 7370 sv = &types.CaptionSourceSettings{} 7371 } else { 7372 sv = *v 7373 } 7374 7375 for key, value := range shape { 7376 switch key { 7377 case "ancillarySourceSettings": 7378 if err := awsRestjson1_deserializeDocumentAncillarySourceSettings(&sv.AncillarySourceSettings, value); err != nil { 7379 return err 7380 } 7381 7382 case "dvbSubSourceSettings": 7383 if err := awsRestjson1_deserializeDocumentDvbSubSourceSettings(&sv.DvbSubSourceSettings, value); err != nil { 7384 return err 7385 } 7386 7387 case "embeddedSourceSettings": 7388 if err := awsRestjson1_deserializeDocumentEmbeddedSourceSettings(&sv.EmbeddedSourceSettings, value); err != nil { 7389 return err 7390 } 7391 7392 case "fileSourceSettings": 7393 if err := awsRestjson1_deserializeDocumentFileSourceSettings(&sv.FileSourceSettings, value); err != nil { 7394 return err 7395 } 7396 7397 case "sourceType": 7398 if value != nil { 7399 jtv, ok := value.(string) 7400 if !ok { 7401 return fmt.Errorf("expected CaptionSourceType to be of type string, got %T instead", value) 7402 } 7403 sv.SourceType = types.CaptionSourceType(jtv) 7404 } 7405 7406 case "teletextSourceSettings": 7407 if err := awsRestjson1_deserializeDocumentTeletextSourceSettings(&sv.TeletextSourceSettings, value); err != nil { 7408 return err 7409 } 7410 7411 case "trackSourceSettings": 7412 if err := awsRestjson1_deserializeDocumentTrackSourceSettings(&sv.TrackSourceSettings, value); err != nil { 7413 return err 7414 } 7415 7416 case "webvttHlsSourceSettings": 7417 if err := awsRestjson1_deserializeDocumentWebvttHlsSourceSettings(&sv.WebvttHlsSourceSettings, value); err != nil { 7418 return err 7419 } 7420 7421 default: 7422 _, _ = key, value 7423 7424 } 7425 } 7426 *v = sv 7427 return nil 7428} 7429 7430func awsRestjson1_deserializeDocumentChannelMapping(v **types.ChannelMapping, value interface{}) error { 7431 if v == nil { 7432 return fmt.Errorf("unexpected nil of type %T", v) 7433 } 7434 if value == nil { 7435 return nil 7436 } 7437 7438 shape, ok := value.(map[string]interface{}) 7439 if !ok { 7440 return fmt.Errorf("unexpected JSON type %v", value) 7441 } 7442 7443 var sv *types.ChannelMapping 7444 if *v == nil { 7445 sv = &types.ChannelMapping{} 7446 } else { 7447 sv = *v 7448 } 7449 7450 for key, value := range shape { 7451 switch key { 7452 case "outputChannels": 7453 if err := awsRestjson1_deserializeDocument__listOfOutputChannelMapping(&sv.OutputChannels, value); err != nil { 7454 return err 7455 } 7456 7457 default: 7458 _, _ = key, value 7459 7460 } 7461 } 7462 *v = sv 7463 return nil 7464} 7465 7466func awsRestjson1_deserializeDocumentCmafAdditionalManifest(v **types.CmafAdditionalManifest, value interface{}) error { 7467 if v == nil { 7468 return fmt.Errorf("unexpected nil of type %T", v) 7469 } 7470 if value == nil { 7471 return nil 7472 } 7473 7474 shape, ok := value.(map[string]interface{}) 7475 if !ok { 7476 return fmt.Errorf("unexpected JSON type %v", value) 7477 } 7478 7479 var sv *types.CmafAdditionalManifest 7480 if *v == nil { 7481 sv = &types.CmafAdditionalManifest{} 7482 } else { 7483 sv = *v 7484 } 7485 7486 for key, value := range shape { 7487 switch key { 7488 case "manifestNameModifier": 7489 if value != nil { 7490 jtv, ok := value.(string) 7491 if !ok { 7492 return fmt.Errorf("expected __stringMin1 to be of type string, got %T instead", value) 7493 } 7494 sv.ManifestNameModifier = ptr.String(jtv) 7495 } 7496 7497 case "selectedOutputs": 7498 if err := awsRestjson1_deserializeDocument__listOf__stringMin1(&sv.SelectedOutputs, value); err != nil { 7499 return err 7500 } 7501 7502 default: 7503 _, _ = key, value 7504 7505 } 7506 } 7507 *v = sv 7508 return nil 7509} 7510 7511func awsRestjson1_deserializeDocumentCmafEncryptionSettings(v **types.CmafEncryptionSettings, value interface{}) error { 7512 if v == nil { 7513 return fmt.Errorf("unexpected nil of type %T", v) 7514 } 7515 if value == nil { 7516 return nil 7517 } 7518 7519 shape, ok := value.(map[string]interface{}) 7520 if !ok { 7521 return fmt.Errorf("unexpected JSON type %v", value) 7522 } 7523 7524 var sv *types.CmafEncryptionSettings 7525 if *v == nil { 7526 sv = &types.CmafEncryptionSettings{} 7527 } else { 7528 sv = *v 7529 } 7530 7531 for key, value := range shape { 7532 switch key { 7533 case "constantInitializationVector": 7534 if value != nil { 7535 jtv, ok := value.(string) 7536 if !ok { 7537 return fmt.Errorf("expected __stringMin32Max32Pattern09aFAF32 to be of type string, got %T instead", value) 7538 } 7539 sv.ConstantInitializationVector = ptr.String(jtv) 7540 } 7541 7542 case "encryptionMethod": 7543 if value != nil { 7544 jtv, ok := value.(string) 7545 if !ok { 7546 return fmt.Errorf("expected CmafEncryptionType to be of type string, got %T instead", value) 7547 } 7548 sv.EncryptionMethod = types.CmafEncryptionType(jtv) 7549 } 7550 7551 case "initializationVectorInManifest": 7552 if value != nil { 7553 jtv, ok := value.(string) 7554 if !ok { 7555 return fmt.Errorf("expected CmafInitializationVectorInManifest to be of type string, got %T instead", value) 7556 } 7557 sv.InitializationVectorInManifest = types.CmafInitializationVectorInManifest(jtv) 7558 } 7559 7560 case "spekeKeyProvider": 7561 if err := awsRestjson1_deserializeDocumentSpekeKeyProviderCmaf(&sv.SpekeKeyProvider, value); err != nil { 7562 return err 7563 } 7564 7565 case "staticKeyProvider": 7566 if err := awsRestjson1_deserializeDocumentStaticKeyProvider(&sv.StaticKeyProvider, value); err != nil { 7567 return err 7568 } 7569 7570 case "type": 7571 if value != nil { 7572 jtv, ok := value.(string) 7573 if !ok { 7574 return fmt.Errorf("expected CmafKeyProviderType to be of type string, got %T instead", value) 7575 } 7576 sv.Type = types.CmafKeyProviderType(jtv) 7577 } 7578 7579 default: 7580 _, _ = key, value 7581 7582 } 7583 } 7584 *v = sv 7585 return nil 7586} 7587 7588func awsRestjson1_deserializeDocumentCmafGroupSettings(v **types.CmafGroupSettings, value interface{}) error { 7589 if v == nil { 7590 return fmt.Errorf("unexpected nil of type %T", v) 7591 } 7592 if value == nil { 7593 return nil 7594 } 7595 7596 shape, ok := value.(map[string]interface{}) 7597 if !ok { 7598 return fmt.Errorf("unexpected JSON type %v", value) 7599 } 7600 7601 var sv *types.CmafGroupSettings 7602 if *v == nil { 7603 sv = &types.CmafGroupSettings{} 7604 } else { 7605 sv = *v 7606 } 7607 7608 for key, value := range shape { 7609 switch key { 7610 case "additionalManifests": 7611 if err := awsRestjson1_deserializeDocument__listOfCmafAdditionalManifest(&sv.AdditionalManifests, value); err != nil { 7612 return err 7613 } 7614 7615 case "baseUrl": 7616 if value != nil { 7617 jtv, ok := value.(string) 7618 if !ok { 7619 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 7620 } 7621 sv.BaseUrl = ptr.String(jtv) 7622 } 7623 7624 case "clientCache": 7625 if value != nil { 7626 jtv, ok := value.(string) 7627 if !ok { 7628 return fmt.Errorf("expected CmafClientCache to be of type string, got %T instead", value) 7629 } 7630 sv.ClientCache = types.CmafClientCache(jtv) 7631 } 7632 7633 case "codecSpecification": 7634 if value != nil { 7635 jtv, ok := value.(string) 7636 if !ok { 7637 return fmt.Errorf("expected CmafCodecSpecification to be of type string, got %T instead", value) 7638 } 7639 sv.CodecSpecification = types.CmafCodecSpecification(jtv) 7640 } 7641 7642 case "destination": 7643 if value != nil { 7644 jtv, ok := value.(string) 7645 if !ok { 7646 return fmt.Errorf("expected __stringPatternS3 to be of type string, got %T instead", value) 7647 } 7648 sv.Destination = ptr.String(jtv) 7649 } 7650 7651 case "destinationSettings": 7652 if err := awsRestjson1_deserializeDocumentDestinationSettings(&sv.DestinationSettings, value); err != nil { 7653 return err 7654 } 7655 7656 case "encryption": 7657 if err := awsRestjson1_deserializeDocumentCmafEncryptionSettings(&sv.Encryption, value); err != nil { 7658 return err 7659 } 7660 7661 case "fragmentLength": 7662 if value != nil { 7663 jtv, ok := value.(json.Number) 7664 if !ok { 7665 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 7666 } 7667 i64, err := jtv.Int64() 7668 if err != nil { 7669 return err 7670 } 7671 sv.FragmentLength = int32(i64) 7672 } 7673 7674 case "imageBasedTrickPlay": 7675 if value != nil { 7676 jtv, ok := value.(string) 7677 if !ok { 7678 return fmt.Errorf("expected CmafImageBasedTrickPlay to be of type string, got %T instead", value) 7679 } 7680 sv.ImageBasedTrickPlay = types.CmafImageBasedTrickPlay(jtv) 7681 } 7682 7683 case "manifestCompression": 7684 if value != nil { 7685 jtv, ok := value.(string) 7686 if !ok { 7687 return fmt.Errorf("expected CmafManifestCompression to be of type string, got %T instead", value) 7688 } 7689 sv.ManifestCompression = types.CmafManifestCompression(jtv) 7690 } 7691 7692 case "manifestDurationFormat": 7693 if value != nil { 7694 jtv, ok := value.(string) 7695 if !ok { 7696 return fmt.Errorf("expected CmafManifestDurationFormat to be of type string, got %T instead", value) 7697 } 7698 sv.ManifestDurationFormat = types.CmafManifestDurationFormat(jtv) 7699 } 7700 7701 case "minBufferTime": 7702 if value != nil { 7703 jtv, ok := value.(json.Number) 7704 if !ok { 7705 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 7706 } 7707 i64, err := jtv.Int64() 7708 if err != nil { 7709 return err 7710 } 7711 sv.MinBufferTime = int32(i64) 7712 } 7713 7714 case "minFinalSegmentLength": 7715 if value != nil { 7716 switch jtv := value.(type) { 7717 case json.Number: 7718 f64, err := jtv.Float64() 7719 if err != nil { 7720 return err 7721 } 7722 sv.MinFinalSegmentLength = f64 7723 7724 case string: 7725 var f64 float64 7726 switch { 7727 case strings.EqualFold(jtv, "NaN"): 7728 f64 = math.NaN() 7729 7730 case strings.EqualFold(jtv, "Infinity"): 7731 f64 = math.Inf(1) 7732 7733 case strings.EqualFold(jtv, "-Infinity"): 7734 f64 = math.Inf(-1) 7735 7736 default: 7737 return fmt.Errorf("unknown JSON number value: %s", jtv) 7738 7739 } 7740 sv.MinFinalSegmentLength = f64 7741 7742 default: 7743 return fmt.Errorf("expected __doubleMin0Max2147483647 to be a JSON Number, got %T instead", value) 7744 7745 } 7746 } 7747 7748 case "mpdProfile": 7749 if value != nil { 7750 jtv, ok := value.(string) 7751 if !ok { 7752 return fmt.Errorf("expected CmafMpdProfile to be of type string, got %T instead", value) 7753 } 7754 sv.MpdProfile = types.CmafMpdProfile(jtv) 7755 } 7756 7757 case "ptsOffsetHandlingForBFrames": 7758 if value != nil { 7759 jtv, ok := value.(string) 7760 if !ok { 7761 return fmt.Errorf("expected CmafPtsOffsetHandlingForBFrames to be of type string, got %T instead", value) 7762 } 7763 sv.PtsOffsetHandlingForBFrames = types.CmafPtsOffsetHandlingForBFrames(jtv) 7764 } 7765 7766 case "segmentControl": 7767 if value != nil { 7768 jtv, ok := value.(string) 7769 if !ok { 7770 return fmt.Errorf("expected CmafSegmentControl to be of type string, got %T instead", value) 7771 } 7772 sv.SegmentControl = types.CmafSegmentControl(jtv) 7773 } 7774 7775 case "segmentLength": 7776 if value != nil { 7777 jtv, ok := value.(json.Number) 7778 if !ok { 7779 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 7780 } 7781 i64, err := jtv.Int64() 7782 if err != nil { 7783 return err 7784 } 7785 sv.SegmentLength = int32(i64) 7786 } 7787 7788 case "segmentLengthControl": 7789 if value != nil { 7790 jtv, ok := value.(string) 7791 if !ok { 7792 return fmt.Errorf("expected CmafSegmentLengthControl to be of type string, got %T instead", value) 7793 } 7794 sv.SegmentLengthControl = types.CmafSegmentLengthControl(jtv) 7795 } 7796 7797 case "streamInfResolution": 7798 if value != nil { 7799 jtv, ok := value.(string) 7800 if !ok { 7801 return fmt.Errorf("expected CmafStreamInfResolution to be of type string, got %T instead", value) 7802 } 7803 sv.StreamInfResolution = types.CmafStreamInfResolution(jtv) 7804 } 7805 7806 case "targetDurationCompatibilityMode": 7807 if value != nil { 7808 jtv, ok := value.(string) 7809 if !ok { 7810 return fmt.Errorf("expected CmafTargetDurationCompatibilityMode to be of type string, got %T instead", value) 7811 } 7812 sv.TargetDurationCompatibilityMode = types.CmafTargetDurationCompatibilityMode(jtv) 7813 } 7814 7815 case "writeDashManifest": 7816 if value != nil { 7817 jtv, ok := value.(string) 7818 if !ok { 7819 return fmt.Errorf("expected CmafWriteDASHManifest to be of type string, got %T instead", value) 7820 } 7821 sv.WriteDashManifest = types.CmafWriteDASHManifest(jtv) 7822 } 7823 7824 case "writeHlsManifest": 7825 if value != nil { 7826 jtv, ok := value.(string) 7827 if !ok { 7828 return fmt.Errorf("expected CmafWriteHLSManifest to be of type string, got %T instead", value) 7829 } 7830 sv.WriteHlsManifest = types.CmafWriteHLSManifest(jtv) 7831 } 7832 7833 case "writeSegmentTimelineInRepresentation": 7834 if value != nil { 7835 jtv, ok := value.(string) 7836 if !ok { 7837 return fmt.Errorf("expected CmafWriteSegmentTimelineInRepresentation to be of type string, got %T instead", value) 7838 } 7839 sv.WriteSegmentTimelineInRepresentation = types.CmafWriteSegmentTimelineInRepresentation(jtv) 7840 } 7841 7842 default: 7843 _, _ = key, value 7844 7845 } 7846 } 7847 *v = sv 7848 return nil 7849} 7850 7851func awsRestjson1_deserializeDocumentCmfcSettings(v **types.CmfcSettings, value interface{}) error { 7852 if v == nil { 7853 return fmt.Errorf("unexpected nil of type %T", v) 7854 } 7855 if value == nil { 7856 return nil 7857 } 7858 7859 shape, ok := value.(map[string]interface{}) 7860 if !ok { 7861 return fmt.Errorf("unexpected JSON type %v", value) 7862 } 7863 7864 var sv *types.CmfcSettings 7865 if *v == nil { 7866 sv = &types.CmfcSettings{} 7867 } else { 7868 sv = *v 7869 } 7870 7871 for key, value := range shape { 7872 switch key { 7873 case "audioDuration": 7874 if value != nil { 7875 jtv, ok := value.(string) 7876 if !ok { 7877 return fmt.Errorf("expected CmfcAudioDuration to be of type string, got %T instead", value) 7878 } 7879 sv.AudioDuration = types.CmfcAudioDuration(jtv) 7880 } 7881 7882 case "audioGroupId": 7883 if value != nil { 7884 jtv, ok := value.(string) 7885 if !ok { 7886 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 7887 } 7888 sv.AudioGroupId = ptr.String(jtv) 7889 } 7890 7891 case "audioRenditionSets": 7892 if value != nil { 7893 jtv, ok := value.(string) 7894 if !ok { 7895 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 7896 } 7897 sv.AudioRenditionSets = ptr.String(jtv) 7898 } 7899 7900 case "audioTrackType": 7901 if value != nil { 7902 jtv, ok := value.(string) 7903 if !ok { 7904 return fmt.Errorf("expected CmfcAudioTrackType to be of type string, got %T instead", value) 7905 } 7906 sv.AudioTrackType = types.CmfcAudioTrackType(jtv) 7907 } 7908 7909 case "descriptiveVideoServiceFlag": 7910 if value != nil { 7911 jtv, ok := value.(string) 7912 if !ok { 7913 return fmt.Errorf("expected CmfcDescriptiveVideoServiceFlag to be of type string, got %T instead", value) 7914 } 7915 sv.DescriptiveVideoServiceFlag = types.CmfcDescriptiveVideoServiceFlag(jtv) 7916 } 7917 7918 case "iFrameOnlyManifest": 7919 if value != nil { 7920 jtv, ok := value.(string) 7921 if !ok { 7922 return fmt.Errorf("expected CmfcIFrameOnlyManifest to be of type string, got %T instead", value) 7923 } 7924 sv.IFrameOnlyManifest = types.CmfcIFrameOnlyManifest(jtv) 7925 } 7926 7927 case "scte35Esam": 7928 if value != nil { 7929 jtv, ok := value.(string) 7930 if !ok { 7931 return fmt.Errorf("expected CmfcScte35Esam to be of type string, got %T instead", value) 7932 } 7933 sv.Scte35Esam = types.CmfcScte35Esam(jtv) 7934 } 7935 7936 case "scte35Source": 7937 if value != nil { 7938 jtv, ok := value.(string) 7939 if !ok { 7940 return fmt.Errorf("expected CmfcScte35Source to be of type string, got %T instead", value) 7941 } 7942 sv.Scte35Source = types.CmfcScte35Source(jtv) 7943 } 7944 7945 default: 7946 _, _ = key, value 7947 7948 } 7949 } 7950 *v = sv 7951 return nil 7952} 7953 7954func awsRestjson1_deserializeDocumentColorCorrector(v **types.ColorCorrector, value interface{}) error { 7955 if v == nil { 7956 return fmt.Errorf("unexpected nil of type %T", v) 7957 } 7958 if value == nil { 7959 return nil 7960 } 7961 7962 shape, ok := value.(map[string]interface{}) 7963 if !ok { 7964 return fmt.Errorf("unexpected JSON type %v", value) 7965 } 7966 7967 var sv *types.ColorCorrector 7968 if *v == nil { 7969 sv = &types.ColorCorrector{} 7970 } else { 7971 sv = *v 7972 } 7973 7974 for key, value := range shape { 7975 switch key { 7976 case "brightness": 7977 if value != nil { 7978 jtv, ok := value.(json.Number) 7979 if !ok { 7980 return fmt.Errorf("expected __integerMin1Max100 to be json.Number, got %T instead", value) 7981 } 7982 i64, err := jtv.Int64() 7983 if err != nil { 7984 return err 7985 } 7986 sv.Brightness = int32(i64) 7987 } 7988 7989 case "colorSpaceConversion": 7990 if value != nil { 7991 jtv, ok := value.(string) 7992 if !ok { 7993 return fmt.Errorf("expected ColorSpaceConversion to be of type string, got %T instead", value) 7994 } 7995 sv.ColorSpaceConversion = types.ColorSpaceConversion(jtv) 7996 } 7997 7998 case "contrast": 7999 if value != nil { 8000 jtv, ok := value.(json.Number) 8001 if !ok { 8002 return fmt.Errorf("expected __integerMin1Max100 to be json.Number, got %T instead", value) 8003 } 8004 i64, err := jtv.Int64() 8005 if err != nil { 8006 return err 8007 } 8008 sv.Contrast = int32(i64) 8009 } 8010 8011 case "hdr10Metadata": 8012 if err := awsRestjson1_deserializeDocumentHdr10Metadata(&sv.Hdr10Metadata, value); err != nil { 8013 return err 8014 } 8015 8016 case "hue": 8017 if value != nil { 8018 jtv, ok := value.(json.Number) 8019 if !ok { 8020 return fmt.Errorf("expected __integerMinNegative180Max180 to be json.Number, got %T instead", value) 8021 } 8022 i64, err := jtv.Int64() 8023 if err != nil { 8024 return err 8025 } 8026 sv.Hue = int32(i64) 8027 } 8028 8029 case "sampleRangeConversion": 8030 if value != nil { 8031 jtv, ok := value.(string) 8032 if !ok { 8033 return fmt.Errorf("expected SampleRangeConversion to be of type string, got %T instead", value) 8034 } 8035 sv.SampleRangeConversion = types.SampleRangeConversion(jtv) 8036 } 8037 8038 case "saturation": 8039 if value != nil { 8040 jtv, ok := value.(json.Number) 8041 if !ok { 8042 return fmt.Errorf("expected __integerMin1Max100 to be json.Number, got %T instead", value) 8043 } 8044 i64, err := jtv.Int64() 8045 if err != nil { 8046 return err 8047 } 8048 sv.Saturation = int32(i64) 8049 } 8050 8051 default: 8052 _, _ = key, value 8053 8054 } 8055 } 8056 *v = sv 8057 return nil 8058} 8059 8060func awsRestjson1_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { 8061 if v == nil { 8062 return fmt.Errorf("unexpected nil of type %T", v) 8063 } 8064 if value == nil { 8065 return nil 8066 } 8067 8068 shape, ok := value.(map[string]interface{}) 8069 if !ok { 8070 return fmt.Errorf("unexpected JSON type %v", value) 8071 } 8072 8073 var sv *types.ConflictException 8074 if *v == nil { 8075 sv = &types.ConflictException{} 8076 } else { 8077 sv = *v 8078 } 8079 8080 for key, value := range shape { 8081 switch key { 8082 case "message": 8083 if value != nil { 8084 jtv, ok := value.(string) 8085 if !ok { 8086 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 8087 } 8088 sv.Message = ptr.String(jtv) 8089 } 8090 8091 default: 8092 _, _ = key, value 8093 8094 } 8095 } 8096 *v = sv 8097 return nil 8098} 8099 8100func awsRestjson1_deserializeDocumentContainerSettings(v **types.ContainerSettings, value interface{}) error { 8101 if v == nil { 8102 return fmt.Errorf("unexpected nil of type %T", v) 8103 } 8104 if value == nil { 8105 return nil 8106 } 8107 8108 shape, ok := value.(map[string]interface{}) 8109 if !ok { 8110 return fmt.Errorf("unexpected JSON type %v", value) 8111 } 8112 8113 var sv *types.ContainerSettings 8114 if *v == nil { 8115 sv = &types.ContainerSettings{} 8116 } else { 8117 sv = *v 8118 } 8119 8120 for key, value := range shape { 8121 switch key { 8122 case "cmfcSettings": 8123 if err := awsRestjson1_deserializeDocumentCmfcSettings(&sv.CmfcSettings, value); err != nil { 8124 return err 8125 } 8126 8127 case "container": 8128 if value != nil { 8129 jtv, ok := value.(string) 8130 if !ok { 8131 return fmt.Errorf("expected ContainerType to be of type string, got %T instead", value) 8132 } 8133 sv.Container = types.ContainerType(jtv) 8134 } 8135 8136 case "f4vSettings": 8137 if err := awsRestjson1_deserializeDocumentF4vSettings(&sv.F4vSettings, value); err != nil { 8138 return err 8139 } 8140 8141 case "m2tsSettings": 8142 if err := awsRestjson1_deserializeDocumentM2tsSettings(&sv.M2tsSettings, value); err != nil { 8143 return err 8144 } 8145 8146 case "m3u8Settings": 8147 if err := awsRestjson1_deserializeDocumentM3u8Settings(&sv.M3u8Settings, value); err != nil { 8148 return err 8149 } 8150 8151 case "movSettings": 8152 if err := awsRestjson1_deserializeDocumentMovSettings(&sv.MovSettings, value); err != nil { 8153 return err 8154 } 8155 8156 case "mp4Settings": 8157 if err := awsRestjson1_deserializeDocumentMp4Settings(&sv.Mp4Settings, value); err != nil { 8158 return err 8159 } 8160 8161 case "mpdSettings": 8162 if err := awsRestjson1_deserializeDocumentMpdSettings(&sv.MpdSettings, value); err != nil { 8163 return err 8164 } 8165 8166 case "mxfSettings": 8167 if err := awsRestjson1_deserializeDocumentMxfSettings(&sv.MxfSettings, value); err != nil { 8168 return err 8169 } 8170 8171 default: 8172 _, _ = key, value 8173 8174 } 8175 } 8176 *v = sv 8177 return nil 8178} 8179 8180func awsRestjson1_deserializeDocumentDashAdditionalManifest(v **types.DashAdditionalManifest, value interface{}) error { 8181 if v == nil { 8182 return fmt.Errorf("unexpected nil of type %T", v) 8183 } 8184 if value == nil { 8185 return nil 8186 } 8187 8188 shape, ok := value.(map[string]interface{}) 8189 if !ok { 8190 return fmt.Errorf("unexpected JSON type %v", value) 8191 } 8192 8193 var sv *types.DashAdditionalManifest 8194 if *v == nil { 8195 sv = &types.DashAdditionalManifest{} 8196 } else { 8197 sv = *v 8198 } 8199 8200 for key, value := range shape { 8201 switch key { 8202 case "manifestNameModifier": 8203 if value != nil { 8204 jtv, ok := value.(string) 8205 if !ok { 8206 return fmt.Errorf("expected __stringMin1 to be of type string, got %T instead", value) 8207 } 8208 sv.ManifestNameModifier = ptr.String(jtv) 8209 } 8210 8211 case "selectedOutputs": 8212 if err := awsRestjson1_deserializeDocument__listOf__stringMin1(&sv.SelectedOutputs, value); err != nil { 8213 return err 8214 } 8215 8216 default: 8217 _, _ = key, value 8218 8219 } 8220 } 8221 *v = sv 8222 return nil 8223} 8224 8225func awsRestjson1_deserializeDocumentDashIsoEncryptionSettings(v **types.DashIsoEncryptionSettings, value interface{}) error { 8226 if v == nil { 8227 return fmt.Errorf("unexpected nil of type %T", v) 8228 } 8229 if value == nil { 8230 return nil 8231 } 8232 8233 shape, ok := value.(map[string]interface{}) 8234 if !ok { 8235 return fmt.Errorf("unexpected JSON type %v", value) 8236 } 8237 8238 var sv *types.DashIsoEncryptionSettings 8239 if *v == nil { 8240 sv = &types.DashIsoEncryptionSettings{} 8241 } else { 8242 sv = *v 8243 } 8244 8245 for key, value := range shape { 8246 switch key { 8247 case "playbackDeviceCompatibility": 8248 if value != nil { 8249 jtv, ok := value.(string) 8250 if !ok { 8251 return fmt.Errorf("expected DashIsoPlaybackDeviceCompatibility to be of type string, got %T instead", value) 8252 } 8253 sv.PlaybackDeviceCompatibility = types.DashIsoPlaybackDeviceCompatibility(jtv) 8254 } 8255 8256 case "spekeKeyProvider": 8257 if err := awsRestjson1_deserializeDocumentSpekeKeyProvider(&sv.SpekeKeyProvider, value); err != nil { 8258 return err 8259 } 8260 8261 default: 8262 _, _ = key, value 8263 8264 } 8265 } 8266 *v = sv 8267 return nil 8268} 8269 8270func awsRestjson1_deserializeDocumentDashIsoGroupSettings(v **types.DashIsoGroupSettings, value interface{}) error { 8271 if v == nil { 8272 return fmt.Errorf("unexpected nil of type %T", v) 8273 } 8274 if value == nil { 8275 return nil 8276 } 8277 8278 shape, ok := value.(map[string]interface{}) 8279 if !ok { 8280 return fmt.Errorf("unexpected JSON type %v", value) 8281 } 8282 8283 var sv *types.DashIsoGroupSettings 8284 if *v == nil { 8285 sv = &types.DashIsoGroupSettings{} 8286 } else { 8287 sv = *v 8288 } 8289 8290 for key, value := range shape { 8291 switch key { 8292 case "additionalManifests": 8293 if err := awsRestjson1_deserializeDocument__listOfDashAdditionalManifest(&sv.AdditionalManifests, value); err != nil { 8294 return err 8295 } 8296 8297 case "audioChannelConfigSchemeIdUri": 8298 if value != nil { 8299 jtv, ok := value.(string) 8300 if !ok { 8301 return fmt.Errorf("expected DashIsoGroupAudioChannelConfigSchemeIdUri to be of type string, got %T instead", value) 8302 } 8303 sv.AudioChannelConfigSchemeIdUri = types.DashIsoGroupAudioChannelConfigSchemeIdUri(jtv) 8304 } 8305 8306 case "baseUrl": 8307 if value != nil { 8308 jtv, ok := value.(string) 8309 if !ok { 8310 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 8311 } 8312 sv.BaseUrl = ptr.String(jtv) 8313 } 8314 8315 case "destination": 8316 if value != nil { 8317 jtv, ok := value.(string) 8318 if !ok { 8319 return fmt.Errorf("expected __stringPatternS3 to be of type string, got %T instead", value) 8320 } 8321 sv.Destination = ptr.String(jtv) 8322 } 8323 8324 case "destinationSettings": 8325 if err := awsRestjson1_deserializeDocumentDestinationSettings(&sv.DestinationSettings, value); err != nil { 8326 return err 8327 } 8328 8329 case "encryption": 8330 if err := awsRestjson1_deserializeDocumentDashIsoEncryptionSettings(&sv.Encryption, value); err != nil { 8331 return err 8332 } 8333 8334 case "fragmentLength": 8335 if value != nil { 8336 jtv, ok := value.(json.Number) 8337 if !ok { 8338 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 8339 } 8340 i64, err := jtv.Int64() 8341 if err != nil { 8342 return err 8343 } 8344 sv.FragmentLength = int32(i64) 8345 } 8346 8347 case "hbbtvCompliance": 8348 if value != nil { 8349 jtv, ok := value.(string) 8350 if !ok { 8351 return fmt.Errorf("expected DashIsoHbbtvCompliance to be of type string, got %T instead", value) 8352 } 8353 sv.HbbtvCompliance = types.DashIsoHbbtvCompliance(jtv) 8354 } 8355 8356 case "imageBasedTrickPlay": 8357 if value != nil { 8358 jtv, ok := value.(string) 8359 if !ok { 8360 return fmt.Errorf("expected DashIsoImageBasedTrickPlay to be of type string, got %T instead", value) 8361 } 8362 sv.ImageBasedTrickPlay = types.DashIsoImageBasedTrickPlay(jtv) 8363 } 8364 8365 case "minBufferTime": 8366 if value != nil { 8367 jtv, ok := value.(json.Number) 8368 if !ok { 8369 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 8370 } 8371 i64, err := jtv.Int64() 8372 if err != nil { 8373 return err 8374 } 8375 sv.MinBufferTime = int32(i64) 8376 } 8377 8378 case "minFinalSegmentLength": 8379 if value != nil { 8380 switch jtv := value.(type) { 8381 case json.Number: 8382 f64, err := jtv.Float64() 8383 if err != nil { 8384 return err 8385 } 8386 sv.MinFinalSegmentLength = f64 8387 8388 case string: 8389 var f64 float64 8390 switch { 8391 case strings.EqualFold(jtv, "NaN"): 8392 f64 = math.NaN() 8393 8394 case strings.EqualFold(jtv, "Infinity"): 8395 f64 = math.Inf(1) 8396 8397 case strings.EqualFold(jtv, "-Infinity"): 8398 f64 = math.Inf(-1) 8399 8400 default: 8401 return fmt.Errorf("unknown JSON number value: %s", jtv) 8402 8403 } 8404 sv.MinFinalSegmentLength = f64 8405 8406 default: 8407 return fmt.Errorf("expected __doubleMin0Max2147483647 to be a JSON Number, got %T instead", value) 8408 8409 } 8410 } 8411 8412 case "mpdProfile": 8413 if value != nil { 8414 jtv, ok := value.(string) 8415 if !ok { 8416 return fmt.Errorf("expected DashIsoMpdProfile to be of type string, got %T instead", value) 8417 } 8418 sv.MpdProfile = types.DashIsoMpdProfile(jtv) 8419 } 8420 8421 case "ptsOffsetHandlingForBFrames": 8422 if value != nil { 8423 jtv, ok := value.(string) 8424 if !ok { 8425 return fmt.Errorf("expected DashIsoPtsOffsetHandlingForBFrames to be of type string, got %T instead", value) 8426 } 8427 sv.PtsOffsetHandlingForBFrames = types.DashIsoPtsOffsetHandlingForBFrames(jtv) 8428 } 8429 8430 case "segmentControl": 8431 if value != nil { 8432 jtv, ok := value.(string) 8433 if !ok { 8434 return fmt.Errorf("expected DashIsoSegmentControl to be of type string, got %T instead", value) 8435 } 8436 sv.SegmentControl = types.DashIsoSegmentControl(jtv) 8437 } 8438 8439 case "segmentLength": 8440 if value != nil { 8441 jtv, ok := value.(json.Number) 8442 if !ok { 8443 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 8444 } 8445 i64, err := jtv.Int64() 8446 if err != nil { 8447 return err 8448 } 8449 sv.SegmentLength = int32(i64) 8450 } 8451 8452 case "segmentLengthControl": 8453 if value != nil { 8454 jtv, ok := value.(string) 8455 if !ok { 8456 return fmt.Errorf("expected DashIsoSegmentLengthControl to be of type string, got %T instead", value) 8457 } 8458 sv.SegmentLengthControl = types.DashIsoSegmentLengthControl(jtv) 8459 } 8460 8461 case "writeSegmentTimelineInRepresentation": 8462 if value != nil { 8463 jtv, ok := value.(string) 8464 if !ok { 8465 return fmt.Errorf("expected DashIsoWriteSegmentTimelineInRepresentation to be of type string, got %T instead", value) 8466 } 8467 sv.WriteSegmentTimelineInRepresentation = types.DashIsoWriteSegmentTimelineInRepresentation(jtv) 8468 } 8469 8470 default: 8471 _, _ = key, value 8472 8473 } 8474 } 8475 *v = sv 8476 return nil 8477} 8478 8479func awsRestjson1_deserializeDocumentDeinterlacer(v **types.Deinterlacer, value interface{}) error { 8480 if v == nil { 8481 return fmt.Errorf("unexpected nil of type %T", v) 8482 } 8483 if value == nil { 8484 return nil 8485 } 8486 8487 shape, ok := value.(map[string]interface{}) 8488 if !ok { 8489 return fmt.Errorf("unexpected JSON type %v", value) 8490 } 8491 8492 var sv *types.Deinterlacer 8493 if *v == nil { 8494 sv = &types.Deinterlacer{} 8495 } else { 8496 sv = *v 8497 } 8498 8499 for key, value := range shape { 8500 switch key { 8501 case "algorithm": 8502 if value != nil { 8503 jtv, ok := value.(string) 8504 if !ok { 8505 return fmt.Errorf("expected DeinterlaceAlgorithm to be of type string, got %T instead", value) 8506 } 8507 sv.Algorithm = types.DeinterlaceAlgorithm(jtv) 8508 } 8509 8510 case "control": 8511 if value != nil { 8512 jtv, ok := value.(string) 8513 if !ok { 8514 return fmt.Errorf("expected DeinterlacerControl to be of type string, got %T instead", value) 8515 } 8516 sv.Control = types.DeinterlacerControl(jtv) 8517 } 8518 8519 case "mode": 8520 if value != nil { 8521 jtv, ok := value.(string) 8522 if !ok { 8523 return fmt.Errorf("expected DeinterlacerMode to be of type string, got %T instead", value) 8524 } 8525 sv.Mode = types.DeinterlacerMode(jtv) 8526 } 8527 8528 default: 8529 _, _ = key, value 8530 8531 } 8532 } 8533 *v = sv 8534 return nil 8535} 8536 8537func awsRestjson1_deserializeDocumentDestinationSettings(v **types.DestinationSettings, value interface{}) error { 8538 if v == nil { 8539 return fmt.Errorf("unexpected nil of type %T", v) 8540 } 8541 if value == nil { 8542 return nil 8543 } 8544 8545 shape, ok := value.(map[string]interface{}) 8546 if !ok { 8547 return fmt.Errorf("unexpected JSON type %v", value) 8548 } 8549 8550 var sv *types.DestinationSettings 8551 if *v == nil { 8552 sv = &types.DestinationSettings{} 8553 } else { 8554 sv = *v 8555 } 8556 8557 for key, value := range shape { 8558 switch key { 8559 case "s3Settings": 8560 if err := awsRestjson1_deserializeDocumentS3DestinationSettings(&sv.S3Settings, value); err != nil { 8561 return err 8562 } 8563 8564 default: 8565 _, _ = key, value 8566 8567 } 8568 } 8569 *v = sv 8570 return nil 8571} 8572 8573func awsRestjson1_deserializeDocumentDolbyVision(v **types.DolbyVision, value interface{}) error { 8574 if v == nil { 8575 return fmt.Errorf("unexpected nil of type %T", v) 8576 } 8577 if value == nil { 8578 return nil 8579 } 8580 8581 shape, ok := value.(map[string]interface{}) 8582 if !ok { 8583 return fmt.Errorf("unexpected JSON type %v", value) 8584 } 8585 8586 var sv *types.DolbyVision 8587 if *v == nil { 8588 sv = &types.DolbyVision{} 8589 } else { 8590 sv = *v 8591 } 8592 8593 for key, value := range shape { 8594 switch key { 8595 case "l6Metadata": 8596 if err := awsRestjson1_deserializeDocumentDolbyVisionLevel6Metadata(&sv.L6Metadata, value); err != nil { 8597 return err 8598 } 8599 8600 case "l6Mode": 8601 if value != nil { 8602 jtv, ok := value.(string) 8603 if !ok { 8604 return fmt.Errorf("expected DolbyVisionLevel6Mode to be of type string, got %T instead", value) 8605 } 8606 sv.L6Mode = types.DolbyVisionLevel6Mode(jtv) 8607 } 8608 8609 case "profile": 8610 if value != nil { 8611 jtv, ok := value.(string) 8612 if !ok { 8613 return fmt.Errorf("expected DolbyVisionProfile to be of type string, got %T instead", value) 8614 } 8615 sv.Profile = types.DolbyVisionProfile(jtv) 8616 } 8617 8618 default: 8619 _, _ = key, value 8620 8621 } 8622 } 8623 *v = sv 8624 return nil 8625} 8626 8627func awsRestjson1_deserializeDocumentDolbyVisionLevel6Metadata(v **types.DolbyVisionLevel6Metadata, value interface{}) error { 8628 if v == nil { 8629 return fmt.Errorf("unexpected nil of type %T", v) 8630 } 8631 if value == nil { 8632 return nil 8633 } 8634 8635 shape, ok := value.(map[string]interface{}) 8636 if !ok { 8637 return fmt.Errorf("unexpected JSON type %v", value) 8638 } 8639 8640 var sv *types.DolbyVisionLevel6Metadata 8641 if *v == nil { 8642 sv = &types.DolbyVisionLevel6Metadata{} 8643 } else { 8644 sv = *v 8645 } 8646 8647 for key, value := range shape { 8648 switch key { 8649 case "maxCll": 8650 if value != nil { 8651 jtv, ok := value.(json.Number) 8652 if !ok { 8653 return fmt.Errorf("expected __integerMin0Max65535 to be json.Number, got %T instead", value) 8654 } 8655 i64, err := jtv.Int64() 8656 if err != nil { 8657 return err 8658 } 8659 sv.MaxCll = int32(i64) 8660 } 8661 8662 case "maxFall": 8663 if value != nil { 8664 jtv, ok := value.(json.Number) 8665 if !ok { 8666 return fmt.Errorf("expected __integerMin0Max65535 to be json.Number, got %T instead", value) 8667 } 8668 i64, err := jtv.Int64() 8669 if err != nil { 8670 return err 8671 } 8672 sv.MaxFall = int32(i64) 8673 } 8674 8675 default: 8676 _, _ = key, value 8677 8678 } 8679 } 8680 *v = sv 8681 return nil 8682} 8683 8684func awsRestjson1_deserializeDocumentDvbNitSettings(v **types.DvbNitSettings, value interface{}) error { 8685 if v == nil { 8686 return fmt.Errorf("unexpected nil of type %T", v) 8687 } 8688 if value == nil { 8689 return nil 8690 } 8691 8692 shape, ok := value.(map[string]interface{}) 8693 if !ok { 8694 return fmt.Errorf("unexpected JSON type %v", value) 8695 } 8696 8697 var sv *types.DvbNitSettings 8698 if *v == nil { 8699 sv = &types.DvbNitSettings{} 8700 } else { 8701 sv = *v 8702 } 8703 8704 for key, value := range shape { 8705 switch key { 8706 case "networkId": 8707 if value != nil { 8708 jtv, ok := value.(json.Number) 8709 if !ok { 8710 return fmt.Errorf("expected __integerMin0Max65535 to be json.Number, got %T instead", value) 8711 } 8712 i64, err := jtv.Int64() 8713 if err != nil { 8714 return err 8715 } 8716 sv.NetworkId = int32(i64) 8717 } 8718 8719 case "networkName": 8720 if value != nil { 8721 jtv, ok := value.(string) 8722 if !ok { 8723 return fmt.Errorf("expected __stringMin1Max256 to be of type string, got %T instead", value) 8724 } 8725 sv.NetworkName = ptr.String(jtv) 8726 } 8727 8728 case "nitInterval": 8729 if value != nil { 8730 jtv, ok := value.(json.Number) 8731 if !ok { 8732 return fmt.Errorf("expected __integerMin25Max10000 to be json.Number, got %T instead", value) 8733 } 8734 i64, err := jtv.Int64() 8735 if err != nil { 8736 return err 8737 } 8738 sv.NitInterval = int32(i64) 8739 } 8740 8741 default: 8742 _, _ = key, value 8743 8744 } 8745 } 8746 *v = sv 8747 return nil 8748} 8749 8750func awsRestjson1_deserializeDocumentDvbSdtSettings(v **types.DvbSdtSettings, value interface{}) error { 8751 if v == nil { 8752 return fmt.Errorf("unexpected nil of type %T", v) 8753 } 8754 if value == nil { 8755 return nil 8756 } 8757 8758 shape, ok := value.(map[string]interface{}) 8759 if !ok { 8760 return fmt.Errorf("unexpected JSON type %v", value) 8761 } 8762 8763 var sv *types.DvbSdtSettings 8764 if *v == nil { 8765 sv = &types.DvbSdtSettings{} 8766 } else { 8767 sv = *v 8768 } 8769 8770 for key, value := range shape { 8771 switch key { 8772 case "outputSdt": 8773 if value != nil { 8774 jtv, ok := value.(string) 8775 if !ok { 8776 return fmt.Errorf("expected OutputSdt to be of type string, got %T instead", value) 8777 } 8778 sv.OutputSdt = types.OutputSdt(jtv) 8779 } 8780 8781 case "sdtInterval": 8782 if value != nil { 8783 jtv, ok := value.(json.Number) 8784 if !ok { 8785 return fmt.Errorf("expected __integerMin25Max2000 to be json.Number, got %T instead", value) 8786 } 8787 i64, err := jtv.Int64() 8788 if err != nil { 8789 return err 8790 } 8791 sv.SdtInterval = int32(i64) 8792 } 8793 8794 case "serviceName": 8795 if value != nil { 8796 jtv, ok := value.(string) 8797 if !ok { 8798 return fmt.Errorf("expected __stringMin1Max256 to be of type string, got %T instead", value) 8799 } 8800 sv.ServiceName = ptr.String(jtv) 8801 } 8802 8803 case "serviceProviderName": 8804 if value != nil { 8805 jtv, ok := value.(string) 8806 if !ok { 8807 return fmt.Errorf("expected __stringMin1Max256 to be of type string, got %T instead", value) 8808 } 8809 sv.ServiceProviderName = ptr.String(jtv) 8810 } 8811 8812 default: 8813 _, _ = key, value 8814 8815 } 8816 } 8817 *v = sv 8818 return nil 8819} 8820 8821func awsRestjson1_deserializeDocumentDvbSubDestinationSettings(v **types.DvbSubDestinationSettings, value interface{}) error { 8822 if v == nil { 8823 return fmt.Errorf("unexpected nil of type %T", v) 8824 } 8825 if value == nil { 8826 return nil 8827 } 8828 8829 shape, ok := value.(map[string]interface{}) 8830 if !ok { 8831 return fmt.Errorf("unexpected JSON type %v", value) 8832 } 8833 8834 var sv *types.DvbSubDestinationSettings 8835 if *v == nil { 8836 sv = &types.DvbSubDestinationSettings{} 8837 } else { 8838 sv = *v 8839 } 8840 8841 for key, value := range shape { 8842 switch key { 8843 case "alignment": 8844 if value != nil { 8845 jtv, ok := value.(string) 8846 if !ok { 8847 return fmt.Errorf("expected DvbSubtitleAlignment to be of type string, got %T instead", value) 8848 } 8849 sv.Alignment = types.DvbSubtitleAlignment(jtv) 8850 } 8851 8852 case "backgroundColor": 8853 if value != nil { 8854 jtv, ok := value.(string) 8855 if !ok { 8856 return fmt.Errorf("expected DvbSubtitleBackgroundColor to be of type string, got %T instead", value) 8857 } 8858 sv.BackgroundColor = types.DvbSubtitleBackgroundColor(jtv) 8859 } 8860 8861 case "backgroundOpacity": 8862 if value != nil { 8863 jtv, ok := value.(json.Number) 8864 if !ok { 8865 return fmt.Errorf("expected __integerMin0Max255 to be json.Number, got %T instead", value) 8866 } 8867 i64, err := jtv.Int64() 8868 if err != nil { 8869 return err 8870 } 8871 sv.BackgroundOpacity = int32(i64) 8872 } 8873 8874 case "ddsHandling": 8875 if value != nil { 8876 jtv, ok := value.(string) 8877 if !ok { 8878 return fmt.Errorf("expected DvbddsHandling to be of type string, got %T instead", value) 8879 } 8880 sv.DdsHandling = types.DvbddsHandling(jtv) 8881 } 8882 8883 case "ddsXCoordinate": 8884 if value != nil { 8885 jtv, ok := value.(json.Number) 8886 if !ok { 8887 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 8888 } 8889 i64, err := jtv.Int64() 8890 if err != nil { 8891 return err 8892 } 8893 sv.DdsXCoordinate = int32(i64) 8894 } 8895 8896 case "ddsYCoordinate": 8897 if value != nil { 8898 jtv, ok := value.(json.Number) 8899 if !ok { 8900 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 8901 } 8902 i64, err := jtv.Int64() 8903 if err != nil { 8904 return err 8905 } 8906 sv.DdsYCoordinate = int32(i64) 8907 } 8908 8909 case "fontColor": 8910 if value != nil { 8911 jtv, ok := value.(string) 8912 if !ok { 8913 return fmt.Errorf("expected DvbSubtitleFontColor to be of type string, got %T instead", value) 8914 } 8915 sv.FontColor = types.DvbSubtitleFontColor(jtv) 8916 } 8917 8918 case "fontOpacity": 8919 if value != nil { 8920 jtv, ok := value.(json.Number) 8921 if !ok { 8922 return fmt.Errorf("expected __integerMin0Max255 to be json.Number, got %T instead", value) 8923 } 8924 i64, err := jtv.Int64() 8925 if err != nil { 8926 return err 8927 } 8928 sv.FontOpacity = int32(i64) 8929 } 8930 8931 case "fontResolution": 8932 if value != nil { 8933 jtv, ok := value.(json.Number) 8934 if !ok { 8935 return fmt.Errorf("expected __integerMin96Max600 to be json.Number, got %T instead", value) 8936 } 8937 i64, err := jtv.Int64() 8938 if err != nil { 8939 return err 8940 } 8941 sv.FontResolution = int32(i64) 8942 } 8943 8944 case "fontScript": 8945 if value != nil { 8946 jtv, ok := value.(string) 8947 if !ok { 8948 return fmt.Errorf("expected FontScript to be of type string, got %T instead", value) 8949 } 8950 sv.FontScript = types.FontScript(jtv) 8951 } 8952 8953 case "fontSize": 8954 if value != nil { 8955 jtv, ok := value.(json.Number) 8956 if !ok { 8957 return fmt.Errorf("expected __integerMin0Max96 to be json.Number, got %T instead", value) 8958 } 8959 i64, err := jtv.Int64() 8960 if err != nil { 8961 return err 8962 } 8963 sv.FontSize = int32(i64) 8964 } 8965 8966 case "height": 8967 if value != nil { 8968 jtv, ok := value.(json.Number) 8969 if !ok { 8970 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 8971 } 8972 i64, err := jtv.Int64() 8973 if err != nil { 8974 return err 8975 } 8976 sv.Height = int32(i64) 8977 } 8978 8979 case "outlineColor": 8980 if value != nil { 8981 jtv, ok := value.(string) 8982 if !ok { 8983 return fmt.Errorf("expected DvbSubtitleOutlineColor to be of type string, got %T instead", value) 8984 } 8985 sv.OutlineColor = types.DvbSubtitleOutlineColor(jtv) 8986 } 8987 8988 case "outlineSize": 8989 if value != nil { 8990 jtv, ok := value.(json.Number) 8991 if !ok { 8992 return fmt.Errorf("expected __integerMin0Max10 to be json.Number, got %T instead", value) 8993 } 8994 i64, err := jtv.Int64() 8995 if err != nil { 8996 return err 8997 } 8998 sv.OutlineSize = int32(i64) 8999 } 9000 9001 case "shadowColor": 9002 if value != nil { 9003 jtv, ok := value.(string) 9004 if !ok { 9005 return fmt.Errorf("expected DvbSubtitleShadowColor to be of type string, got %T instead", value) 9006 } 9007 sv.ShadowColor = types.DvbSubtitleShadowColor(jtv) 9008 } 9009 9010 case "shadowOpacity": 9011 if value != nil { 9012 jtv, ok := value.(json.Number) 9013 if !ok { 9014 return fmt.Errorf("expected __integerMin0Max255 to be json.Number, got %T instead", value) 9015 } 9016 i64, err := jtv.Int64() 9017 if err != nil { 9018 return err 9019 } 9020 sv.ShadowOpacity = int32(i64) 9021 } 9022 9023 case "shadowXOffset": 9024 if value != nil { 9025 jtv, ok := value.(json.Number) 9026 if !ok { 9027 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 9028 } 9029 i64, err := jtv.Int64() 9030 if err != nil { 9031 return err 9032 } 9033 sv.ShadowXOffset = int32(i64) 9034 } 9035 9036 case "shadowYOffset": 9037 if value != nil { 9038 jtv, ok := value.(json.Number) 9039 if !ok { 9040 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 9041 } 9042 i64, err := jtv.Int64() 9043 if err != nil { 9044 return err 9045 } 9046 sv.ShadowYOffset = int32(i64) 9047 } 9048 9049 case "subtitlingType": 9050 if value != nil { 9051 jtv, ok := value.(string) 9052 if !ok { 9053 return fmt.Errorf("expected DvbSubtitlingType to be of type string, got %T instead", value) 9054 } 9055 sv.SubtitlingType = types.DvbSubtitlingType(jtv) 9056 } 9057 9058 case "teletextSpacing": 9059 if value != nil { 9060 jtv, ok := value.(string) 9061 if !ok { 9062 return fmt.Errorf("expected DvbSubtitleTeletextSpacing to be of type string, got %T instead", value) 9063 } 9064 sv.TeletextSpacing = types.DvbSubtitleTeletextSpacing(jtv) 9065 } 9066 9067 case "width": 9068 if value != nil { 9069 jtv, ok := value.(json.Number) 9070 if !ok { 9071 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 9072 } 9073 i64, err := jtv.Int64() 9074 if err != nil { 9075 return err 9076 } 9077 sv.Width = int32(i64) 9078 } 9079 9080 case "xPosition": 9081 if value != nil { 9082 jtv, ok := value.(json.Number) 9083 if !ok { 9084 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 9085 } 9086 i64, err := jtv.Int64() 9087 if err != nil { 9088 return err 9089 } 9090 sv.XPosition = int32(i64) 9091 } 9092 9093 case "yPosition": 9094 if value != nil { 9095 jtv, ok := value.(json.Number) 9096 if !ok { 9097 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 9098 } 9099 i64, err := jtv.Int64() 9100 if err != nil { 9101 return err 9102 } 9103 sv.YPosition = int32(i64) 9104 } 9105 9106 default: 9107 _, _ = key, value 9108 9109 } 9110 } 9111 *v = sv 9112 return nil 9113} 9114 9115func awsRestjson1_deserializeDocumentDvbSubSourceSettings(v **types.DvbSubSourceSettings, value interface{}) error { 9116 if v == nil { 9117 return fmt.Errorf("unexpected nil of type %T", v) 9118 } 9119 if value == nil { 9120 return nil 9121 } 9122 9123 shape, ok := value.(map[string]interface{}) 9124 if !ok { 9125 return fmt.Errorf("unexpected JSON type %v", value) 9126 } 9127 9128 var sv *types.DvbSubSourceSettings 9129 if *v == nil { 9130 sv = &types.DvbSubSourceSettings{} 9131 } else { 9132 sv = *v 9133 } 9134 9135 for key, value := range shape { 9136 switch key { 9137 case "pid": 9138 if value != nil { 9139 jtv, ok := value.(json.Number) 9140 if !ok { 9141 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 9142 } 9143 i64, err := jtv.Int64() 9144 if err != nil { 9145 return err 9146 } 9147 sv.Pid = int32(i64) 9148 } 9149 9150 default: 9151 _, _ = key, value 9152 9153 } 9154 } 9155 *v = sv 9156 return nil 9157} 9158 9159func awsRestjson1_deserializeDocumentDvbTdtSettings(v **types.DvbTdtSettings, value interface{}) error { 9160 if v == nil { 9161 return fmt.Errorf("unexpected nil of type %T", v) 9162 } 9163 if value == nil { 9164 return nil 9165 } 9166 9167 shape, ok := value.(map[string]interface{}) 9168 if !ok { 9169 return fmt.Errorf("unexpected JSON type %v", value) 9170 } 9171 9172 var sv *types.DvbTdtSettings 9173 if *v == nil { 9174 sv = &types.DvbTdtSettings{} 9175 } else { 9176 sv = *v 9177 } 9178 9179 for key, value := range shape { 9180 switch key { 9181 case "tdtInterval": 9182 if value != nil { 9183 jtv, ok := value.(json.Number) 9184 if !ok { 9185 return fmt.Errorf("expected __integerMin1000Max30000 to be json.Number, got %T instead", value) 9186 } 9187 i64, err := jtv.Int64() 9188 if err != nil { 9189 return err 9190 } 9191 sv.TdtInterval = int32(i64) 9192 } 9193 9194 default: 9195 _, _ = key, value 9196 9197 } 9198 } 9199 *v = sv 9200 return nil 9201} 9202 9203func awsRestjson1_deserializeDocumentEac3AtmosSettings(v **types.Eac3AtmosSettings, value interface{}) error { 9204 if v == nil { 9205 return fmt.Errorf("unexpected nil of type %T", v) 9206 } 9207 if value == nil { 9208 return nil 9209 } 9210 9211 shape, ok := value.(map[string]interface{}) 9212 if !ok { 9213 return fmt.Errorf("unexpected JSON type %v", value) 9214 } 9215 9216 var sv *types.Eac3AtmosSettings 9217 if *v == nil { 9218 sv = &types.Eac3AtmosSettings{} 9219 } else { 9220 sv = *v 9221 } 9222 9223 for key, value := range shape { 9224 switch key { 9225 case "bitrate": 9226 if value != nil { 9227 jtv, ok := value.(json.Number) 9228 if !ok { 9229 return fmt.Errorf("expected __integerMin384000Max1024000 to be json.Number, got %T instead", value) 9230 } 9231 i64, err := jtv.Int64() 9232 if err != nil { 9233 return err 9234 } 9235 sv.Bitrate = int32(i64) 9236 } 9237 9238 case "bitstreamMode": 9239 if value != nil { 9240 jtv, ok := value.(string) 9241 if !ok { 9242 return fmt.Errorf("expected Eac3AtmosBitstreamMode to be of type string, got %T instead", value) 9243 } 9244 sv.BitstreamMode = types.Eac3AtmosBitstreamMode(jtv) 9245 } 9246 9247 case "codingMode": 9248 if value != nil { 9249 jtv, ok := value.(string) 9250 if !ok { 9251 return fmt.Errorf("expected Eac3AtmosCodingMode to be of type string, got %T instead", value) 9252 } 9253 sv.CodingMode = types.Eac3AtmosCodingMode(jtv) 9254 } 9255 9256 case "dialogueIntelligence": 9257 if value != nil { 9258 jtv, ok := value.(string) 9259 if !ok { 9260 return fmt.Errorf("expected Eac3AtmosDialogueIntelligence to be of type string, got %T instead", value) 9261 } 9262 sv.DialogueIntelligence = types.Eac3AtmosDialogueIntelligence(jtv) 9263 } 9264 9265 case "downmixControl": 9266 if value != nil { 9267 jtv, ok := value.(string) 9268 if !ok { 9269 return fmt.Errorf("expected Eac3AtmosDownmixControl to be of type string, got %T instead", value) 9270 } 9271 sv.DownmixControl = types.Eac3AtmosDownmixControl(jtv) 9272 } 9273 9274 case "dynamicRangeCompressionLine": 9275 if value != nil { 9276 jtv, ok := value.(string) 9277 if !ok { 9278 return fmt.Errorf("expected Eac3AtmosDynamicRangeCompressionLine to be of type string, got %T instead", value) 9279 } 9280 sv.DynamicRangeCompressionLine = types.Eac3AtmosDynamicRangeCompressionLine(jtv) 9281 } 9282 9283 case "dynamicRangeCompressionRf": 9284 if value != nil { 9285 jtv, ok := value.(string) 9286 if !ok { 9287 return fmt.Errorf("expected Eac3AtmosDynamicRangeCompressionRf to be of type string, got %T instead", value) 9288 } 9289 sv.DynamicRangeCompressionRf = types.Eac3AtmosDynamicRangeCompressionRf(jtv) 9290 } 9291 9292 case "dynamicRangeControl": 9293 if value != nil { 9294 jtv, ok := value.(string) 9295 if !ok { 9296 return fmt.Errorf("expected Eac3AtmosDynamicRangeControl to be of type string, got %T instead", value) 9297 } 9298 sv.DynamicRangeControl = types.Eac3AtmosDynamicRangeControl(jtv) 9299 } 9300 9301 case "loRoCenterMixLevel": 9302 if value != nil { 9303 switch jtv := value.(type) { 9304 case json.Number: 9305 f64, err := jtv.Float64() 9306 if err != nil { 9307 return err 9308 } 9309 sv.LoRoCenterMixLevel = f64 9310 9311 case string: 9312 var f64 float64 9313 switch { 9314 case strings.EqualFold(jtv, "NaN"): 9315 f64 = math.NaN() 9316 9317 case strings.EqualFold(jtv, "Infinity"): 9318 f64 = math.Inf(1) 9319 9320 case strings.EqualFold(jtv, "-Infinity"): 9321 f64 = math.Inf(-1) 9322 9323 default: 9324 return fmt.Errorf("unknown JSON number value: %s", jtv) 9325 9326 } 9327 sv.LoRoCenterMixLevel = f64 9328 9329 default: 9330 return fmt.Errorf("expected __doubleMinNegative6Max3 to be a JSON Number, got %T instead", value) 9331 9332 } 9333 } 9334 9335 case "loRoSurroundMixLevel": 9336 if value != nil { 9337 switch jtv := value.(type) { 9338 case json.Number: 9339 f64, err := jtv.Float64() 9340 if err != nil { 9341 return err 9342 } 9343 sv.LoRoSurroundMixLevel = f64 9344 9345 case string: 9346 var f64 float64 9347 switch { 9348 case strings.EqualFold(jtv, "NaN"): 9349 f64 = math.NaN() 9350 9351 case strings.EqualFold(jtv, "Infinity"): 9352 f64 = math.Inf(1) 9353 9354 case strings.EqualFold(jtv, "-Infinity"): 9355 f64 = math.Inf(-1) 9356 9357 default: 9358 return fmt.Errorf("unknown JSON number value: %s", jtv) 9359 9360 } 9361 sv.LoRoSurroundMixLevel = f64 9362 9363 default: 9364 return fmt.Errorf("expected __doubleMinNegative60MaxNegative1 to be a JSON Number, got %T instead", value) 9365 9366 } 9367 } 9368 9369 case "ltRtCenterMixLevel": 9370 if value != nil { 9371 switch jtv := value.(type) { 9372 case json.Number: 9373 f64, err := jtv.Float64() 9374 if err != nil { 9375 return err 9376 } 9377 sv.LtRtCenterMixLevel = f64 9378 9379 case string: 9380 var f64 float64 9381 switch { 9382 case strings.EqualFold(jtv, "NaN"): 9383 f64 = math.NaN() 9384 9385 case strings.EqualFold(jtv, "Infinity"): 9386 f64 = math.Inf(1) 9387 9388 case strings.EqualFold(jtv, "-Infinity"): 9389 f64 = math.Inf(-1) 9390 9391 default: 9392 return fmt.Errorf("unknown JSON number value: %s", jtv) 9393 9394 } 9395 sv.LtRtCenterMixLevel = f64 9396 9397 default: 9398 return fmt.Errorf("expected __doubleMinNegative6Max3 to be a JSON Number, got %T instead", value) 9399 9400 } 9401 } 9402 9403 case "ltRtSurroundMixLevel": 9404 if value != nil { 9405 switch jtv := value.(type) { 9406 case json.Number: 9407 f64, err := jtv.Float64() 9408 if err != nil { 9409 return err 9410 } 9411 sv.LtRtSurroundMixLevel = f64 9412 9413 case string: 9414 var f64 float64 9415 switch { 9416 case strings.EqualFold(jtv, "NaN"): 9417 f64 = math.NaN() 9418 9419 case strings.EqualFold(jtv, "Infinity"): 9420 f64 = math.Inf(1) 9421 9422 case strings.EqualFold(jtv, "-Infinity"): 9423 f64 = math.Inf(-1) 9424 9425 default: 9426 return fmt.Errorf("unknown JSON number value: %s", jtv) 9427 9428 } 9429 sv.LtRtSurroundMixLevel = f64 9430 9431 default: 9432 return fmt.Errorf("expected __doubleMinNegative60MaxNegative1 to be a JSON Number, got %T instead", value) 9433 9434 } 9435 } 9436 9437 case "meteringMode": 9438 if value != nil { 9439 jtv, ok := value.(string) 9440 if !ok { 9441 return fmt.Errorf("expected Eac3AtmosMeteringMode to be of type string, got %T instead", value) 9442 } 9443 sv.MeteringMode = types.Eac3AtmosMeteringMode(jtv) 9444 } 9445 9446 case "sampleRate": 9447 if value != nil { 9448 jtv, ok := value.(json.Number) 9449 if !ok { 9450 return fmt.Errorf("expected __integerMin48000Max48000 to be json.Number, got %T instead", value) 9451 } 9452 i64, err := jtv.Int64() 9453 if err != nil { 9454 return err 9455 } 9456 sv.SampleRate = int32(i64) 9457 } 9458 9459 case "speechThreshold": 9460 if value != nil { 9461 jtv, ok := value.(json.Number) 9462 if !ok { 9463 return fmt.Errorf("expected __integerMin0Max100 to be json.Number, got %T instead", value) 9464 } 9465 i64, err := jtv.Int64() 9466 if err != nil { 9467 return err 9468 } 9469 sv.SpeechThreshold = int32(i64) 9470 } 9471 9472 case "stereoDownmix": 9473 if value != nil { 9474 jtv, ok := value.(string) 9475 if !ok { 9476 return fmt.Errorf("expected Eac3AtmosStereoDownmix to be of type string, got %T instead", value) 9477 } 9478 sv.StereoDownmix = types.Eac3AtmosStereoDownmix(jtv) 9479 } 9480 9481 case "surroundExMode": 9482 if value != nil { 9483 jtv, ok := value.(string) 9484 if !ok { 9485 return fmt.Errorf("expected Eac3AtmosSurroundExMode to be of type string, got %T instead", value) 9486 } 9487 sv.SurroundExMode = types.Eac3AtmosSurroundExMode(jtv) 9488 } 9489 9490 default: 9491 _, _ = key, value 9492 9493 } 9494 } 9495 *v = sv 9496 return nil 9497} 9498 9499func awsRestjson1_deserializeDocumentEac3Settings(v **types.Eac3Settings, value interface{}) error { 9500 if v == nil { 9501 return fmt.Errorf("unexpected nil of type %T", v) 9502 } 9503 if value == nil { 9504 return nil 9505 } 9506 9507 shape, ok := value.(map[string]interface{}) 9508 if !ok { 9509 return fmt.Errorf("unexpected JSON type %v", value) 9510 } 9511 9512 var sv *types.Eac3Settings 9513 if *v == nil { 9514 sv = &types.Eac3Settings{} 9515 } else { 9516 sv = *v 9517 } 9518 9519 for key, value := range shape { 9520 switch key { 9521 case "attenuationControl": 9522 if value != nil { 9523 jtv, ok := value.(string) 9524 if !ok { 9525 return fmt.Errorf("expected Eac3AttenuationControl to be of type string, got %T instead", value) 9526 } 9527 sv.AttenuationControl = types.Eac3AttenuationControl(jtv) 9528 } 9529 9530 case "bitrate": 9531 if value != nil { 9532 jtv, ok := value.(json.Number) 9533 if !ok { 9534 return fmt.Errorf("expected __integerMin64000Max640000 to be json.Number, got %T instead", value) 9535 } 9536 i64, err := jtv.Int64() 9537 if err != nil { 9538 return err 9539 } 9540 sv.Bitrate = int32(i64) 9541 } 9542 9543 case "bitstreamMode": 9544 if value != nil { 9545 jtv, ok := value.(string) 9546 if !ok { 9547 return fmt.Errorf("expected Eac3BitstreamMode to be of type string, got %T instead", value) 9548 } 9549 sv.BitstreamMode = types.Eac3BitstreamMode(jtv) 9550 } 9551 9552 case "codingMode": 9553 if value != nil { 9554 jtv, ok := value.(string) 9555 if !ok { 9556 return fmt.Errorf("expected Eac3CodingMode to be of type string, got %T instead", value) 9557 } 9558 sv.CodingMode = types.Eac3CodingMode(jtv) 9559 } 9560 9561 case "dcFilter": 9562 if value != nil { 9563 jtv, ok := value.(string) 9564 if !ok { 9565 return fmt.Errorf("expected Eac3DcFilter to be of type string, got %T instead", value) 9566 } 9567 sv.DcFilter = types.Eac3DcFilter(jtv) 9568 } 9569 9570 case "dialnorm": 9571 if value != nil { 9572 jtv, ok := value.(json.Number) 9573 if !ok { 9574 return fmt.Errorf("expected __integerMin1Max31 to be json.Number, got %T instead", value) 9575 } 9576 i64, err := jtv.Int64() 9577 if err != nil { 9578 return err 9579 } 9580 sv.Dialnorm = int32(i64) 9581 } 9582 9583 case "dynamicRangeCompressionLine": 9584 if value != nil { 9585 jtv, ok := value.(string) 9586 if !ok { 9587 return fmt.Errorf("expected Eac3DynamicRangeCompressionLine to be of type string, got %T instead", value) 9588 } 9589 sv.DynamicRangeCompressionLine = types.Eac3DynamicRangeCompressionLine(jtv) 9590 } 9591 9592 case "dynamicRangeCompressionRf": 9593 if value != nil { 9594 jtv, ok := value.(string) 9595 if !ok { 9596 return fmt.Errorf("expected Eac3DynamicRangeCompressionRf to be of type string, got %T instead", value) 9597 } 9598 sv.DynamicRangeCompressionRf = types.Eac3DynamicRangeCompressionRf(jtv) 9599 } 9600 9601 case "lfeControl": 9602 if value != nil { 9603 jtv, ok := value.(string) 9604 if !ok { 9605 return fmt.Errorf("expected Eac3LfeControl to be of type string, got %T instead", value) 9606 } 9607 sv.LfeControl = types.Eac3LfeControl(jtv) 9608 } 9609 9610 case "lfeFilter": 9611 if value != nil { 9612 jtv, ok := value.(string) 9613 if !ok { 9614 return fmt.Errorf("expected Eac3LfeFilter to be of type string, got %T instead", value) 9615 } 9616 sv.LfeFilter = types.Eac3LfeFilter(jtv) 9617 } 9618 9619 case "loRoCenterMixLevel": 9620 if value != nil { 9621 switch jtv := value.(type) { 9622 case json.Number: 9623 f64, err := jtv.Float64() 9624 if err != nil { 9625 return err 9626 } 9627 sv.LoRoCenterMixLevel = f64 9628 9629 case string: 9630 var f64 float64 9631 switch { 9632 case strings.EqualFold(jtv, "NaN"): 9633 f64 = math.NaN() 9634 9635 case strings.EqualFold(jtv, "Infinity"): 9636 f64 = math.Inf(1) 9637 9638 case strings.EqualFold(jtv, "-Infinity"): 9639 f64 = math.Inf(-1) 9640 9641 default: 9642 return fmt.Errorf("unknown JSON number value: %s", jtv) 9643 9644 } 9645 sv.LoRoCenterMixLevel = f64 9646 9647 default: 9648 return fmt.Errorf("expected __doubleMinNegative60Max3 to be a JSON Number, got %T instead", value) 9649 9650 } 9651 } 9652 9653 case "loRoSurroundMixLevel": 9654 if value != nil { 9655 switch jtv := value.(type) { 9656 case json.Number: 9657 f64, err := jtv.Float64() 9658 if err != nil { 9659 return err 9660 } 9661 sv.LoRoSurroundMixLevel = f64 9662 9663 case string: 9664 var f64 float64 9665 switch { 9666 case strings.EqualFold(jtv, "NaN"): 9667 f64 = math.NaN() 9668 9669 case strings.EqualFold(jtv, "Infinity"): 9670 f64 = math.Inf(1) 9671 9672 case strings.EqualFold(jtv, "-Infinity"): 9673 f64 = math.Inf(-1) 9674 9675 default: 9676 return fmt.Errorf("unknown JSON number value: %s", jtv) 9677 9678 } 9679 sv.LoRoSurroundMixLevel = f64 9680 9681 default: 9682 return fmt.Errorf("expected __doubleMinNegative60MaxNegative1 to be a JSON Number, got %T instead", value) 9683 9684 } 9685 } 9686 9687 case "ltRtCenterMixLevel": 9688 if value != nil { 9689 switch jtv := value.(type) { 9690 case json.Number: 9691 f64, err := jtv.Float64() 9692 if err != nil { 9693 return err 9694 } 9695 sv.LtRtCenterMixLevel = f64 9696 9697 case string: 9698 var f64 float64 9699 switch { 9700 case strings.EqualFold(jtv, "NaN"): 9701 f64 = math.NaN() 9702 9703 case strings.EqualFold(jtv, "Infinity"): 9704 f64 = math.Inf(1) 9705 9706 case strings.EqualFold(jtv, "-Infinity"): 9707 f64 = math.Inf(-1) 9708 9709 default: 9710 return fmt.Errorf("unknown JSON number value: %s", jtv) 9711 9712 } 9713 sv.LtRtCenterMixLevel = f64 9714 9715 default: 9716 return fmt.Errorf("expected __doubleMinNegative60Max3 to be a JSON Number, got %T instead", value) 9717 9718 } 9719 } 9720 9721 case "ltRtSurroundMixLevel": 9722 if value != nil { 9723 switch jtv := value.(type) { 9724 case json.Number: 9725 f64, err := jtv.Float64() 9726 if err != nil { 9727 return err 9728 } 9729 sv.LtRtSurroundMixLevel = f64 9730 9731 case string: 9732 var f64 float64 9733 switch { 9734 case strings.EqualFold(jtv, "NaN"): 9735 f64 = math.NaN() 9736 9737 case strings.EqualFold(jtv, "Infinity"): 9738 f64 = math.Inf(1) 9739 9740 case strings.EqualFold(jtv, "-Infinity"): 9741 f64 = math.Inf(-1) 9742 9743 default: 9744 return fmt.Errorf("unknown JSON number value: %s", jtv) 9745 9746 } 9747 sv.LtRtSurroundMixLevel = f64 9748 9749 default: 9750 return fmt.Errorf("expected __doubleMinNegative60MaxNegative1 to be a JSON Number, got %T instead", value) 9751 9752 } 9753 } 9754 9755 case "metadataControl": 9756 if value != nil { 9757 jtv, ok := value.(string) 9758 if !ok { 9759 return fmt.Errorf("expected Eac3MetadataControl to be of type string, got %T instead", value) 9760 } 9761 sv.MetadataControl = types.Eac3MetadataControl(jtv) 9762 } 9763 9764 case "passthroughControl": 9765 if value != nil { 9766 jtv, ok := value.(string) 9767 if !ok { 9768 return fmt.Errorf("expected Eac3PassthroughControl to be of type string, got %T instead", value) 9769 } 9770 sv.PassthroughControl = types.Eac3PassthroughControl(jtv) 9771 } 9772 9773 case "phaseControl": 9774 if value != nil { 9775 jtv, ok := value.(string) 9776 if !ok { 9777 return fmt.Errorf("expected Eac3PhaseControl to be of type string, got %T instead", value) 9778 } 9779 sv.PhaseControl = types.Eac3PhaseControl(jtv) 9780 } 9781 9782 case "sampleRate": 9783 if value != nil { 9784 jtv, ok := value.(json.Number) 9785 if !ok { 9786 return fmt.Errorf("expected __integerMin48000Max48000 to be json.Number, got %T instead", value) 9787 } 9788 i64, err := jtv.Int64() 9789 if err != nil { 9790 return err 9791 } 9792 sv.SampleRate = int32(i64) 9793 } 9794 9795 case "stereoDownmix": 9796 if value != nil { 9797 jtv, ok := value.(string) 9798 if !ok { 9799 return fmt.Errorf("expected Eac3StereoDownmix to be of type string, got %T instead", value) 9800 } 9801 sv.StereoDownmix = types.Eac3StereoDownmix(jtv) 9802 } 9803 9804 case "surroundExMode": 9805 if value != nil { 9806 jtv, ok := value.(string) 9807 if !ok { 9808 return fmt.Errorf("expected Eac3SurroundExMode to be of type string, got %T instead", value) 9809 } 9810 sv.SurroundExMode = types.Eac3SurroundExMode(jtv) 9811 } 9812 9813 case "surroundMode": 9814 if value != nil { 9815 jtv, ok := value.(string) 9816 if !ok { 9817 return fmt.Errorf("expected Eac3SurroundMode to be of type string, got %T instead", value) 9818 } 9819 sv.SurroundMode = types.Eac3SurroundMode(jtv) 9820 } 9821 9822 default: 9823 _, _ = key, value 9824 9825 } 9826 } 9827 *v = sv 9828 return nil 9829} 9830 9831func awsRestjson1_deserializeDocumentEmbeddedDestinationSettings(v **types.EmbeddedDestinationSettings, value interface{}) error { 9832 if v == nil { 9833 return fmt.Errorf("unexpected nil of type %T", v) 9834 } 9835 if value == nil { 9836 return nil 9837 } 9838 9839 shape, ok := value.(map[string]interface{}) 9840 if !ok { 9841 return fmt.Errorf("unexpected JSON type %v", value) 9842 } 9843 9844 var sv *types.EmbeddedDestinationSettings 9845 if *v == nil { 9846 sv = &types.EmbeddedDestinationSettings{} 9847 } else { 9848 sv = *v 9849 } 9850 9851 for key, value := range shape { 9852 switch key { 9853 case "destination608ChannelNumber": 9854 if value != nil { 9855 jtv, ok := value.(json.Number) 9856 if !ok { 9857 return fmt.Errorf("expected __integerMin1Max4 to be json.Number, got %T instead", value) 9858 } 9859 i64, err := jtv.Int64() 9860 if err != nil { 9861 return err 9862 } 9863 sv.Destination608ChannelNumber = int32(i64) 9864 } 9865 9866 case "destination708ServiceNumber": 9867 if value != nil { 9868 jtv, ok := value.(json.Number) 9869 if !ok { 9870 return fmt.Errorf("expected __integerMin1Max6 to be json.Number, got %T instead", value) 9871 } 9872 i64, err := jtv.Int64() 9873 if err != nil { 9874 return err 9875 } 9876 sv.Destination708ServiceNumber = int32(i64) 9877 } 9878 9879 default: 9880 _, _ = key, value 9881 9882 } 9883 } 9884 *v = sv 9885 return nil 9886} 9887 9888func awsRestjson1_deserializeDocumentEmbeddedSourceSettings(v **types.EmbeddedSourceSettings, value interface{}) error { 9889 if v == nil { 9890 return fmt.Errorf("unexpected nil of type %T", v) 9891 } 9892 if value == nil { 9893 return nil 9894 } 9895 9896 shape, ok := value.(map[string]interface{}) 9897 if !ok { 9898 return fmt.Errorf("unexpected JSON type %v", value) 9899 } 9900 9901 var sv *types.EmbeddedSourceSettings 9902 if *v == nil { 9903 sv = &types.EmbeddedSourceSettings{} 9904 } else { 9905 sv = *v 9906 } 9907 9908 for key, value := range shape { 9909 switch key { 9910 case "convert608To708": 9911 if value != nil { 9912 jtv, ok := value.(string) 9913 if !ok { 9914 return fmt.Errorf("expected EmbeddedConvert608To708 to be of type string, got %T instead", value) 9915 } 9916 sv.Convert608To708 = types.EmbeddedConvert608To708(jtv) 9917 } 9918 9919 case "source608ChannelNumber": 9920 if value != nil { 9921 jtv, ok := value.(json.Number) 9922 if !ok { 9923 return fmt.Errorf("expected __integerMin1Max4 to be json.Number, got %T instead", value) 9924 } 9925 i64, err := jtv.Int64() 9926 if err != nil { 9927 return err 9928 } 9929 sv.Source608ChannelNumber = int32(i64) 9930 } 9931 9932 case "source608TrackNumber": 9933 if value != nil { 9934 jtv, ok := value.(json.Number) 9935 if !ok { 9936 return fmt.Errorf("expected __integerMin1Max1 to be json.Number, got %T instead", value) 9937 } 9938 i64, err := jtv.Int64() 9939 if err != nil { 9940 return err 9941 } 9942 sv.Source608TrackNumber = int32(i64) 9943 } 9944 9945 case "terminateCaptions": 9946 if value != nil { 9947 jtv, ok := value.(string) 9948 if !ok { 9949 return fmt.Errorf("expected EmbeddedTerminateCaptions to be of type string, got %T instead", value) 9950 } 9951 sv.TerminateCaptions = types.EmbeddedTerminateCaptions(jtv) 9952 } 9953 9954 default: 9955 _, _ = key, value 9956 9957 } 9958 } 9959 *v = sv 9960 return nil 9961} 9962 9963func awsRestjson1_deserializeDocumentEndpoint(v **types.Endpoint, value interface{}) error { 9964 if v == nil { 9965 return fmt.Errorf("unexpected nil of type %T", v) 9966 } 9967 if value == nil { 9968 return nil 9969 } 9970 9971 shape, ok := value.(map[string]interface{}) 9972 if !ok { 9973 return fmt.Errorf("unexpected JSON type %v", value) 9974 } 9975 9976 var sv *types.Endpoint 9977 if *v == nil { 9978 sv = &types.Endpoint{} 9979 } else { 9980 sv = *v 9981 } 9982 9983 for key, value := range shape { 9984 switch key { 9985 case "url": 9986 if value != nil { 9987 jtv, ok := value.(string) 9988 if !ok { 9989 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9990 } 9991 sv.Url = ptr.String(jtv) 9992 } 9993 9994 default: 9995 _, _ = key, value 9996 9997 } 9998 } 9999 *v = sv 10000 return nil 10001} 10002 10003func awsRestjson1_deserializeDocumentEsamManifestConfirmConditionNotification(v **types.EsamManifestConfirmConditionNotification, value interface{}) error { 10004 if v == nil { 10005 return fmt.Errorf("unexpected nil of type %T", v) 10006 } 10007 if value == nil { 10008 return nil 10009 } 10010 10011 shape, ok := value.(map[string]interface{}) 10012 if !ok { 10013 return fmt.Errorf("unexpected JSON type %v", value) 10014 } 10015 10016 var sv *types.EsamManifestConfirmConditionNotification 10017 if *v == nil { 10018 sv = &types.EsamManifestConfirmConditionNotification{} 10019 } else { 10020 sv = *v 10021 } 10022 10023 for key, value := range shape { 10024 switch key { 10025 case "mccXml": 10026 if value != nil { 10027 jtv, ok := value.(string) 10028 if !ok { 10029 return fmt.Errorf("expected __stringPatternSNManifestConfirmConditionNotificationNS to be of type string, got %T instead", value) 10030 } 10031 sv.MccXml = ptr.String(jtv) 10032 } 10033 10034 default: 10035 _, _ = key, value 10036 10037 } 10038 } 10039 *v = sv 10040 return nil 10041} 10042 10043func awsRestjson1_deserializeDocumentEsamSettings(v **types.EsamSettings, value interface{}) error { 10044 if v == nil { 10045 return fmt.Errorf("unexpected nil of type %T", v) 10046 } 10047 if value == nil { 10048 return nil 10049 } 10050 10051 shape, ok := value.(map[string]interface{}) 10052 if !ok { 10053 return fmt.Errorf("unexpected JSON type %v", value) 10054 } 10055 10056 var sv *types.EsamSettings 10057 if *v == nil { 10058 sv = &types.EsamSettings{} 10059 } else { 10060 sv = *v 10061 } 10062 10063 for key, value := range shape { 10064 switch key { 10065 case "manifestConfirmConditionNotification": 10066 if err := awsRestjson1_deserializeDocumentEsamManifestConfirmConditionNotification(&sv.ManifestConfirmConditionNotification, value); err != nil { 10067 return err 10068 } 10069 10070 case "responseSignalPreroll": 10071 if value != nil { 10072 jtv, ok := value.(json.Number) 10073 if !ok { 10074 return fmt.Errorf("expected __integerMin0Max30000 to be json.Number, got %T instead", value) 10075 } 10076 i64, err := jtv.Int64() 10077 if err != nil { 10078 return err 10079 } 10080 sv.ResponseSignalPreroll = int32(i64) 10081 } 10082 10083 case "signalProcessingNotification": 10084 if err := awsRestjson1_deserializeDocumentEsamSignalProcessingNotification(&sv.SignalProcessingNotification, value); err != nil { 10085 return err 10086 } 10087 10088 default: 10089 _, _ = key, value 10090 10091 } 10092 } 10093 *v = sv 10094 return nil 10095} 10096 10097func awsRestjson1_deserializeDocumentEsamSignalProcessingNotification(v **types.EsamSignalProcessingNotification, value interface{}) error { 10098 if v == nil { 10099 return fmt.Errorf("unexpected nil of type %T", v) 10100 } 10101 if value == nil { 10102 return nil 10103 } 10104 10105 shape, ok := value.(map[string]interface{}) 10106 if !ok { 10107 return fmt.Errorf("unexpected JSON type %v", value) 10108 } 10109 10110 var sv *types.EsamSignalProcessingNotification 10111 if *v == nil { 10112 sv = &types.EsamSignalProcessingNotification{} 10113 } else { 10114 sv = *v 10115 } 10116 10117 for key, value := range shape { 10118 switch key { 10119 case "sccXml": 10120 if value != nil { 10121 jtv, ok := value.(string) 10122 if !ok { 10123 return fmt.Errorf("expected __stringPatternSNSignalProcessingNotificationNS to be of type string, got %T instead", value) 10124 } 10125 sv.SccXml = ptr.String(jtv) 10126 } 10127 10128 default: 10129 _, _ = key, value 10130 10131 } 10132 } 10133 *v = sv 10134 return nil 10135} 10136 10137func awsRestjson1_deserializeDocumentExtendedDataServices(v **types.ExtendedDataServices, value interface{}) error { 10138 if v == nil { 10139 return fmt.Errorf("unexpected nil of type %T", v) 10140 } 10141 if value == nil { 10142 return nil 10143 } 10144 10145 shape, ok := value.(map[string]interface{}) 10146 if !ok { 10147 return fmt.Errorf("unexpected JSON type %v", value) 10148 } 10149 10150 var sv *types.ExtendedDataServices 10151 if *v == nil { 10152 sv = &types.ExtendedDataServices{} 10153 } else { 10154 sv = *v 10155 } 10156 10157 for key, value := range shape { 10158 switch key { 10159 case "copyProtectionAction": 10160 if value != nil { 10161 jtv, ok := value.(string) 10162 if !ok { 10163 return fmt.Errorf("expected CopyProtectionAction to be of type string, got %T instead", value) 10164 } 10165 sv.CopyProtectionAction = types.CopyProtectionAction(jtv) 10166 } 10167 10168 case "vchipAction": 10169 if value != nil { 10170 jtv, ok := value.(string) 10171 if !ok { 10172 return fmt.Errorf("expected VchipAction to be of type string, got %T instead", value) 10173 } 10174 sv.VchipAction = types.VchipAction(jtv) 10175 } 10176 10177 default: 10178 _, _ = key, value 10179 10180 } 10181 } 10182 *v = sv 10183 return nil 10184} 10185 10186func awsRestjson1_deserializeDocumentF4vSettings(v **types.F4vSettings, value interface{}) error { 10187 if v == nil { 10188 return fmt.Errorf("unexpected nil of type %T", v) 10189 } 10190 if value == nil { 10191 return nil 10192 } 10193 10194 shape, ok := value.(map[string]interface{}) 10195 if !ok { 10196 return fmt.Errorf("unexpected JSON type %v", value) 10197 } 10198 10199 var sv *types.F4vSettings 10200 if *v == nil { 10201 sv = &types.F4vSettings{} 10202 } else { 10203 sv = *v 10204 } 10205 10206 for key, value := range shape { 10207 switch key { 10208 case "moovPlacement": 10209 if value != nil { 10210 jtv, ok := value.(string) 10211 if !ok { 10212 return fmt.Errorf("expected F4vMoovPlacement to be of type string, got %T instead", value) 10213 } 10214 sv.MoovPlacement = types.F4vMoovPlacement(jtv) 10215 } 10216 10217 default: 10218 _, _ = key, value 10219 10220 } 10221 } 10222 *v = sv 10223 return nil 10224} 10225 10226func awsRestjson1_deserializeDocumentFileGroupSettings(v **types.FileGroupSettings, value interface{}) error { 10227 if v == nil { 10228 return fmt.Errorf("unexpected nil of type %T", v) 10229 } 10230 if value == nil { 10231 return nil 10232 } 10233 10234 shape, ok := value.(map[string]interface{}) 10235 if !ok { 10236 return fmt.Errorf("unexpected JSON type %v", value) 10237 } 10238 10239 var sv *types.FileGroupSettings 10240 if *v == nil { 10241 sv = &types.FileGroupSettings{} 10242 } else { 10243 sv = *v 10244 } 10245 10246 for key, value := range shape { 10247 switch key { 10248 case "destination": 10249 if value != nil { 10250 jtv, ok := value.(string) 10251 if !ok { 10252 return fmt.Errorf("expected __stringPatternS3 to be of type string, got %T instead", value) 10253 } 10254 sv.Destination = ptr.String(jtv) 10255 } 10256 10257 case "destinationSettings": 10258 if err := awsRestjson1_deserializeDocumentDestinationSettings(&sv.DestinationSettings, value); err != nil { 10259 return err 10260 } 10261 10262 default: 10263 _, _ = key, value 10264 10265 } 10266 } 10267 *v = sv 10268 return nil 10269} 10270 10271func awsRestjson1_deserializeDocumentFileSourceSettings(v **types.FileSourceSettings, value interface{}) error { 10272 if v == nil { 10273 return fmt.Errorf("unexpected nil of type %T", v) 10274 } 10275 if value == nil { 10276 return nil 10277 } 10278 10279 shape, ok := value.(map[string]interface{}) 10280 if !ok { 10281 return fmt.Errorf("unexpected JSON type %v", value) 10282 } 10283 10284 var sv *types.FileSourceSettings 10285 if *v == nil { 10286 sv = &types.FileSourceSettings{} 10287 } else { 10288 sv = *v 10289 } 10290 10291 for key, value := range shape { 10292 switch key { 10293 case "convert608To708": 10294 if value != nil { 10295 jtv, ok := value.(string) 10296 if !ok { 10297 return fmt.Errorf("expected FileSourceConvert608To708 to be of type string, got %T instead", value) 10298 } 10299 sv.Convert608To708 = types.FileSourceConvert608To708(jtv) 10300 } 10301 10302 case "framerate": 10303 if err := awsRestjson1_deserializeDocumentCaptionSourceFramerate(&sv.Framerate, value); err != nil { 10304 return err 10305 } 10306 10307 case "sourceFile": 10308 if value != nil { 10309 jtv, ok := value.(string) 10310 if !ok { 10311 return fmt.Errorf("expected __stringMin14PatternS3SccSCCTtmlTTMLDfxpDFXPStlSTLSrtSRTXmlXMLSmiSMIVttVTTWebvttWEBVTTHttpsSccSCCTtmlTTMLDfxpDFXPStlSTLSrtSRTXmlXMLSmiSMIVttVTTWebvttWEBVTT to be of type string, got %T instead", value) 10312 } 10313 sv.SourceFile = ptr.String(jtv) 10314 } 10315 10316 case "timeDelta": 10317 if value != nil { 10318 jtv, ok := value.(json.Number) 10319 if !ok { 10320 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 10321 } 10322 i64, err := jtv.Int64() 10323 if err != nil { 10324 return err 10325 } 10326 sv.TimeDelta = int32(i64) 10327 } 10328 10329 default: 10330 _, _ = key, value 10331 10332 } 10333 } 10334 *v = sv 10335 return nil 10336} 10337 10338func awsRestjson1_deserializeDocumentForbiddenException(v **types.ForbiddenException, value interface{}) error { 10339 if v == nil { 10340 return fmt.Errorf("unexpected nil of type %T", v) 10341 } 10342 if value == nil { 10343 return nil 10344 } 10345 10346 shape, ok := value.(map[string]interface{}) 10347 if !ok { 10348 return fmt.Errorf("unexpected JSON type %v", value) 10349 } 10350 10351 var sv *types.ForbiddenException 10352 if *v == nil { 10353 sv = &types.ForbiddenException{} 10354 } else { 10355 sv = *v 10356 } 10357 10358 for key, value := range shape { 10359 switch key { 10360 case "message": 10361 if value != nil { 10362 jtv, ok := value.(string) 10363 if !ok { 10364 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 10365 } 10366 sv.Message = ptr.String(jtv) 10367 } 10368 10369 default: 10370 _, _ = key, value 10371 10372 } 10373 } 10374 *v = sv 10375 return nil 10376} 10377 10378func awsRestjson1_deserializeDocumentFrameCaptureSettings(v **types.FrameCaptureSettings, value interface{}) error { 10379 if v == nil { 10380 return fmt.Errorf("unexpected nil of type %T", v) 10381 } 10382 if value == nil { 10383 return nil 10384 } 10385 10386 shape, ok := value.(map[string]interface{}) 10387 if !ok { 10388 return fmt.Errorf("unexpected JSON type %v", value) 10389 } 10390 10391 var sv *types.FrameCaptureSettings 10392 if *v == nil { 10393 sv = &types.FrameCaptureSettings{} 10394 } else { 10395 sv = *v 10396 } 10397 10398 for key, value := range shape { 10399 switch key { 10400 case "framerateDenominator": 10401 if value != nil { 10402 jtv, ok := value.(json.Number) 10403 if !ok { 10404 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 10405 } 10406 i64, err := jtv.Int64() 10407 if err != nil { 10408 return err 10409 } 10410 sv.FramerateDenominator = int32(i64) 10411 } 10412 10413 case "framerateNumerator": 10414 if value != nil { 10415 jtv, ok := value.(json.Number) 10416 if !ok { 10417 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 10418 } 10419 i64, err := jtv.Int64() 10420 if err != nil { 10421 return err 10422 } 10423 sv.FramerateNumerator = int32(i64) 10424 } 10425 10426 case "maxCaptures": 10427 if value != nil { 10428 jtv, ok := value.(json.Number) 10429 if !ok { 10430 return fmt.Errorf("expected __integerMin1Max10000000 to be json.Number, got %T instead", value) 10431 } 10432 i64, err := jtv.Int64() 10433 if err != nil { 10434 return err 10435 } 10436 sv.MaxCaptures = int32(i64) 10437 } 10438 10439 case "quality": 10440 if value != nil { 10441 jtv, ok := value.(json.Number) 10442 if !ok { 10443 return fmt.Errorf("expected __integerMin1Max100 to be json.Number, got %T instead", value) 10444 } 10445 i64, err := jtv.Int64() 10446 if err != nil { 10447 return err 10448 } 10449 sv.Quality = int32(i64) 10450 } 10451 10452 default: 10453 _, _ = key, value 10454 10455 } 10456 } 10457 *v = sv 10458 return nil 10459} 10460 10461func awsRestjson1_deserializeDocumentH264QvbrSettings(v **types.H264QvbrSettings, value interface{}) error { 10462 if v == nil { 10463 return fmt.Errorf("unexpected nil of type %T", v) 10464 } 10465 if value == nil { 10466 return nil 10467 } 10468 10469 shape, ok := value.(map[string]interface{}) 10470 if !ok { 10471 return fmt.Errorf("unexpected JSON type %v", value) 10472 } 10473 10474 var sv *types.H264QvbrSettings 10475 if *v == nil { 10476 sv = &types.H264QvbrSettings{} 10477 } else { 10478 sv = *v 10479 } 10480 10481 for key, value := range shape { 10482 switch key { 10483 case "maxAverageBitrate": 10484 if value != nil { 10485 jtv, ok := value.(json.Number) 10486 if !ok { 10487 return fmt.Errorf("expected __integerMin1000Max1152000000 to be json.Number, got %T instead", value) 10488 } 10489 i64, err := jtv.Int64() 10490 if err != nil { 10491 return err 10492 } 10493 sv.MaxAverageBitrate = int32(i64) 10494 } 10495 10496 case "qvbrQualityLevel": 10497 if value != nil { 10498 jtv, ok := value.(json.Number) 10499 if !ok { 10500 return fmt.Errorf("expected __integerMin1Max10 to be json.Number, got %T instead", value) 10501 } 10502 i64, err := jtv.Int64() 10503 if err != nil { 10504 return err 10505 } 10506 sv.QvbrQualityLevel = int32(i64) 10507 } 10508 10509 case "qvbrQualityLevelFineTune": 10510 if value != nil { 10511 switch jtv := value.(type) { 10512 case json.Number: 10513 f64, err := jtv.Float64() 10514 if err != nil { 10515 return err 10516 } 10517 sv.QvbrQualityLevelFineTune = f64 10518 10519 case string: 10520 var f64 float64 10521 switch { 10522 case strings.EqualFold(jtv, "NaN"): 10523 f64 = math.NaN() 10524 10525 case strings.EqualFold(jtv, "Infinity"): 10526 f64 = math.Inf(1) 10527 10528 case strings.EqualFold(jtv, "-Infinity"): 10529 f64 = math.Inf(-1) 10530 10531 default: 10532 return fmt.Errorf("unknown JSON number value: %s", jtv) 10533 10534 } 10535 sv.QvbrQualityLevelFineTune = f64 10536 10537 default: 10538 return fmt.Errorf("expected __doubleMin0Max1 to be a JSON Number, got %T instead", value) 10539 10540 } 10541 } 10542 10543 default: 10544 _, _ = key, value 10545 10546 } 10547 } 10548 *v = sv 10549 return nil 10550} 10551 10552func awsRestjson1_deserializeDocumentH264Settings(v **types.H264Settings, value interface{}) error { 10553 if v == nil { 10554 return fmt.Errorf("unexpected nil of type %T", v) 10555 } 10556 if value == nil { 10557 return nil 10558 } 10559 10560 shape, ok := value.(map[string]interface{}) 10561 if !ok { 10562 return fmt.Errorf("unexpected JSON type %v", value) 10563 } 10564 10565 var sv *types.H264Settings 10566 if *v == nil { 10567 sv = &types.H264Settings{} 10568 } else { 10569 sv = *v 10570 } 10571 10572 for key, value := range shape { 10573 switch key { 10574 case "adaptiveQuantization": 10575 if value != nil { 10576 jtv, ok := value.(string) 10577 if !ok { 10578 return fmt.Errorf("expected H264AdaptiveQuantization to be of type string, got %T instead", value) 10579 } 10580 sv.AdaptiveQuantization = types.H264AdaptiveQuantization(jtv) 10581 } 10582 10583 case "bitrate": 10584 if value != nil { 10585 jtv, ok := value.(json.Number) 10586 if !ok { 10587 return fmt.Errorf("expected __integerMin1000Max1152000000 to be json.Number, got %T instead", value) 10588 } 10589 i64, err := jtv.Int64() 10590 if err != nil { 10591 return err 10592 } 10593 sv.Bitrate = int32(i64) 10594 } 10595 10596 case "codecLevel": 10597 if value != nil { 10598 jtv, ok := value.(string) 10599 if !ok { 10600 return fmt.Errorf("expected H264CodecLevel to be of type string, got %T instead", value) 10601 } 10602 sv.CodecLevel = types.H264CodecLevel(jtv) 10603 } 10604 10605 case "codecProfile": 10606 if value != nil { 10607 jtv, ok := value.(string) 10608 if !ok { 10609 return fmt.Errorf("expected H264CodecProfile to be of type string, got %T instead", value) 10610 } 10611 sv.CodecProfile = types.H264CodecProfile(jtv) 10612 } 10613 10614 case "dynamicSubGop": 10615 if value != nil { 10616 jtv, ok := value.(string) 10617 if !ok { 10618 return fmt.Errorf("expected H264DynamicSubGop to be of type string, got %T instead", value) 10619 } 10620 sv.DynamicSubGop = types.H264DynamicSubGop(jtv) 10621 } 10622 10623 case "entropyEncoding": 10624 if value != nil { 10625 jtv, ok := value.(string) 10626 if !ok { 10627 return fmt.Errorf("expected H264EntropyEncoding to be of type string, got %T instead", value) 10628 } 10629 sv.EntropyEncoding = types.H264EntropyEncoding(jtv) 10630 } 10631 10632 case "fieldEncoding": 10633 if value != nil { 10634 jtv, ok := value.(string) 10635 if !ok { 10636 return fmt.Errorf("expected H264FieldEncoding to be of type string, got %T instead", value) 10637 } 10638 sv.FieldEncoding = types.H264FieldEncoding(jtv) 10639 } 10640 10641 case "flickerAdaptiveQuantization": 10642 if value != nil { 10643 jtv, ok := value.(string) 10644 if !ok { 10645 return fmt.Errorf("expected H264FlickerAdaptiveQuantization to be of type string, got %T instead", value) 10646 } 10647 sv.FlickerAdaptiveQuantization = types.H264FlickerAdaptiveQuantization(jtv) 10648 } 10649 10650 case "framerateControl": 10651 if value != nil { 10652 jtv, ok := value.(string) 10653 if !ok { 10654 return fmt.Errorf("expected H264FramerateControl to be of type string, got %T instead", value) 10655 } 10656 sv.FramerateControl = types.H264FramerateControl(jtv) 10657 } 10658 10659 case "framerateConversionAlgorithm": 10660 if value != nil { 10661 jtv, ok := value.(string) 10662 if !ok { 10663 return fmt.Errorf("expected H264FramerateConversionAlgorithm to be of type string, got %T instead", value) 10664 } 10665 sv.FramerateConversionAlgorithm = types.H264FramerateConversionAlgorithm(jtv) 10666 } 10667 10668 case "framerateDenominator": 10669 if value != nil { 10670 jtv, ok := value.(json.Number) 10671 if !ok { 10672 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 10673 } 10674 i64, err := jtv.Int64() 10675 if err != nil { 10676 return err 10677 } 10678 sv.FramerateDenominator = int32(i64) 10679 } 10680 10681 case "framerateNumerator": 10682 if value != nil { 10683 jtv, ok := value.(json.Number) 10684 if !ok { 10685 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 10686 } 10687 i64, err := jtv.Int64() 10688 if err != nil { 10689 return err 10690 } 10691 sv.FramerateNumerator = int32(i64) 10692 } 10693 10694 case "gopBReference": 10695 if value != nil { 10696 jtv, ok := value.(string) 10697 if !ok { 10698 return fmt.Errorf("expected H264GopBReference to be of type string, got %T instead", value) 10699 } 10700 sv.GopBReference = types.H264GopBReference(jtv) 10701 } 10702 10703 case "gopClosedCadence": 10704 if value != nil { 10705 jtv, ok := value.(json.Number) 10706 if !ok { 10707 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 10708 } 10709 i64, err := jtv.Int64() 10710 if err != nil { 10711 return err 10712 } 10713 sv.GopClosedCadence = int32(i64) 10714 } 10715 10716 case "gopSize": 10717 if value != nil { 10718 switch jtv := value.(type) { 10719 case json.Number: 10720 f64, err := jtv.Float64() 10721 if err != nil { 10722 return err 10723 } 10724 sv.GopSize = f64 10725 10726 case string: 10727 var f64 float64 10728 switch { 10729 case strings.EqualFold(jtv, "NaN"): 10730 f64 = math.NaN() 10731 10732 case strings.EqualFold(jtv, "Infinity"): 10733 f64 = math.Inf(1) 10734 10735 case strings.EqualFold(jtv, "-Infinity"): 10736 f64 = math.Inf(-1) 10737 10738 default: 10739 return fmt.Errorf("unknown JSON number value: %s", jtv) 10740 10741 } 10742 sv.GopSize = f64 10743 10744 default: 10745 return fmt.Errorf("expected __doubleMin0 to be a JSON Number, got %T instead", value) 10746 10747 } 10748 } 10749 10750 case "gopSizeUnits": 10751 if value != nil { 10752 jtv, ok := value.(string) 10753 if !ok { 10754 return fmt.Errorf("expected H264GopSizeUnits to be of type string, got %T instead", value) 10755 } 10756 sv.GopSizeUnits = types.H264GopSizeUnits(jtv) 10757 } 10758 10759 case "hrdBufferInitialFillPercentage": 10760 if value != nil { 10761 jtv, ok := value.(json.Number) 10762 if !ok { 10763 return fmt.Errorf("expected __integerMin0Max100 to be json.Number, got %T instead", value) 10764 } 10765 i64, err := jtv.Int64() 10766 if err != nil { 10767 return err 10768 } 10769 sv.HrdBufferInitialFillPercentage = int32(i64) 10770 } 10771 10772 case "hrdBufferSize": 10773 if value != nil { 10774 jtv, ok := value.(json.Number) 10775 if !ok { 10776 return fmt.Errorf("expected __integerMin0Max1152000000 to be json.Number, got %T instead", value) 10777 } 10778 i64, err := jtv.Int64() 10779 if err != nil { 10780 return err 10781 } 10782 sv.HrdBufferSize = int32(i64) 10783 } 10784 10785 case "interlaceMode": 10786 if value != nil { 10787 jtv, ok := value.(string) 10788 if !ok { 10789 return fmt.Errorf("expected H264InterlaceMode to be of type string, got %T instead", value) 10790 } 10791 sv.InterlaceMode = types.H264InterlaceMode(jtv) 10792 } 10793 10794 case "maxBitrate": 10795 if value != nil { 10796 jtv, ok := value.(json.Number) 10797 if !ok { 10798 return fmt.Errorf("expected __integerMin1000Max1152000000 to be json.Number, got %T instead", value) 10799 } 10800 i64, err := jtv.Int64() 10801 if err != nil { 10802 return err 10803 } 10804 sv.MaxBitrate = int32(i64) 10805 } 10806 10807 case "minIInterval": 10808 if value != nil { 10809 jtv, ok := value.(json.Number) 10810 if !ok { 10811 return fmt.Errorf("expected __integerMin0Max30 to be json.Number, got %T instead", value) 10812 } 10813 i64, err := jtv.Int64() 10814 if err != nil { 10815 return err 10816 } 10817 sv.MinIInterval = int32(i64) 10818 } 10819 10820 case "numberBFramesBetweenReferenceFrames": 10821 if value != nil { 10822 jtv, ok := value.(json.Number) 10823 if !ok { 10824 return fmt.Errorf("expected __integerMin0Max7 to be json.Number, got %T instead", value) 10825 } 10826 i64, err := jtv.Int64() 10827 if err != nil { 10828 return err 10829 } 10830 sv.NumberBFramesBetweenReferenceFrames = int32(i64) 10831 } 10832 10833 case "numberReferenceFrames": 10834 if value != nil { 10835 jtv, ok := value.(json.Number) 10836 if !ok { 10837 return fmt.Errorf("expected __integerMin1Max6 to be json.Number, got %T instead", value) 10838 } 10839 i64, err := jtv.Int64() 10840 if err != nil { 10841 return err 10842 } 10843 sv.NumberReferenceFrames = int32(i64) 10844 } 10845 10846 case "parControl": 10847 if value != nil { 10848 jtv, ok := value.(string) 10849 if !ok { 10850 return fmt.Errorf("expected H264ParControl to be of type string, got %T instead", value) 10851 } 10852 sv.ParControl = types.H264ParControl(jtv) 10853 } 10854 10855 case "parDenominator": 10856 if value != nil { 10857 jtv, ok := value.(json.Number) 10858 if !ok { 10859 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 10860 } 10861 i64, err := jtv.Int64() 10862 if err != nil { 10863 return err 10864 } 10865 sv.ParDenominator = int32(i64) 10866 } 10867 10868 case "parNumerator": 10869 if value != nil { 10870 jtv, ok := value.(json.Number) 10871 if !ok { 10872 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 10873 } 10874 i64, err := jtv.Int64() 10875 if err != nil { 10876 return err 10877 } 10878 sv.ParNumerator = int32(i64) 10879 } 10880 10881 case "qualityTuningLevel": 10882 if value != nil { 10883 jtv, ok := value.(string) 10884 if !ok { 10885 return fmt.Errorf("expected H264QualityTuningLevel to be of type string, got %T instead", value) 10886 } 10887 sv.QualityTuningLevel = types.H264QualityTuningLevel(jtv) 10888 } 10889 10890 case "qvbrSettings": 10891 if err := awsRestjson1_deserializeDocumentH264QvbrSettings(&sv.QvbrSettings, value); err != nil { 10892 return err 10893 } 10894 10895 case "rateControlMode": 10896 if value != nil { 10897 jtv, ok := value.(string) 10898 if !ok { 10899 return fmt.Errorf("expected H264RateControlMode to be of type string, got %T instead", value) 10900 } 10901 sv.RateControlMode = types.H264RateControlMode(jtv) 10902 } 10903 10904 case "repeatPps": 10905 if value != nil { 10906 jtv, ok := value.(string) 10907 if !ok { 10908 return fmt.Errorf("expected H264RepeatPps to be of type string, got %T instead", value) 10909 } 10910 sv.RepeatPps = types.H264RepeatPps(jtv) 10911 } 10912 10913 case "scanTypeConversionMode": 10914 if value != nil { 10915 jtv, ok := value.(string) 10916 if !ok { 10917 return fmt.Errorf("expected H264ScanTypeConversionMode to be of type string, got %T instead", value) 10918 } 10919 sv.ScanTypeConversionMode = types.H264ScanTypeConversionMode(jtv) 10920 } 10921 10922 case "sceneChangeDetect": 10923 if value != nil { 10924 jtv, ok := value.(string) 10925 if !ok { 10926 return fmt.Errorf("expected H264SceneChangeDetect to be of type string, got %T instead", value) 10927 } 10928 sv.SceneChangeDetect = types.H264SceneChangeDetect(jtv) 10929 } 10930 10931 case "slices": 10932 if value != nil { 10933 jtv, ok := value.(json.Number) 10934 if !ok { 10935 return fmt.Errorf("expected __integerMin1Max32 to be json.Number, got %T instead", value) 10936 } 10937 i64, err := jtv.Int64() 10938 if err != nil { 10939 return err 10940 } 10941 sv.Slices = int32(i64) 10942 } 10943 10944 case "slowPal": 10945 if value != nil { 10946 jtv, ok := value.(string) 10947 if !ok { 10948 return fmt.Errorf("expected H264SlowPal to be of type string, got %T instead", value) 10949 } 10950 sv.SlowPal = types.H264SlowPal(jtv) 10951 } 10952 10953 case "softness": 10954 if value != nil { 10955 jtv, ok := value.(json.Number) 10956 if !ok { 10957 return fmt.Errorf("expected __integerMin0Max128 to be json.Number, got %T instead", value) 10958 } 10959 i64, err := jtv.Int64() 10960 if err != nil { 10961 return err 10962 } 10963 sv.Softness = int32(i64) 10964 } 10965 10966 case "spatialAdaptiveQuantization": 10967 if value != nil { 10968 jtv, ok := value.(string) 10969 if !ok { 10970 return fmt.Errorf("expected H264SpatialAdaptiveQuantization to be of type string, got %T instead", value) 10971 } 10972 sv.SpatialAdaptiveQuantization = types.H264SpatialAdaptiveQuantization(jtv) 10973 } 10974 10975 case "syntax": 10976 if value != nil { 10977 jtv, ok := value.(string) 10978 if !ok { 10979 return fmt.Errorf("expected H264Syntax to be of type string, got %T instead", value) 10980 } 10981 sv.Syntax = types.H264Syntax(jtv) 10982 } 10983 10984 case "telecine": 10985 if value != nil { 10986 jtv, ok := value.(string) 10987 if !ok { 10988 return fmt.Errorf("expected H264Telecine to be of type string, got %T instead", value) 10989 } 10990 sv.Telecine = types.H264Telecine(jtv) 10991 } 10992 10993 case "temporalAdaptiveQuantization": 10994 if value != nil { 10995 jtv, ok := value.(string) 10996 if !ok { 10997 return fmt.Errorf("expected H264TemporalAdaptiveQuantization to be of type string, got %T instead", value) 10998 } 10999 sv.TemporalAdaptiveQuantization = types.H264TemporalAdaptiveQuantization(jtv) 11000 } 11001 11002 case "unregisteredSeiTimecode": 11003 if value != nil { 11004 jtv, ok := value.(string) 11005 if !ok { 11006 return fmt.Errorf("expected H264UnregisteredSeiTimecode to be of type string, got %T instead", value) 11007 } 11008 sv.UnregisteredSeiTimecode = types.H264UnregisteredSeiTimecode(jtv) 11009 } 11010 11011 default: 11012 _, _ = key, value 11013 11014 } 11015 } 11016 *v = sv 11017 return nil 11018} 11019 11020func awsRestjson1_deserializeDocumentH265QvbrSettings(v **types.H265QvbrSettings, value interface{}) error { 11021 if v == nil { 11022 return fmt.Errorf("unexpected nil of type %T", v) 11023 } 11024 if value == nil { 11025 return nil 11026 } 11027 11028 shape, ok := value.(map[string]interface{}) 11029 if !ok { 11030 return fmt.Errorf("unexpected JSON type %v", value) 11031 } 11032 11033 var sv *types.H265QvbrSettings 11034 if *v == nil { 11035 sv = &types.H265QvbrSettings{} 11036 } else { 11037 sv = *v 11038 } 11039 11040 for key, value := range shape { 11041 switch key { 11042 case "maxAverageBitrate": 11043 if value != nil { 11044 jtv, ok := value.(json.Number) 11045 if !ok { 11046 return fmt.Errorf("expected __integerMin1000Max1466400000 to be json.Number, got %T instead", value) 11047 } 11048 i64, err := jtv.Int64() 11049 if err != nil { 11050 return err 11051 } 11052 sv.MaxAverageBitrate = int32(i64) 11053 } 11054 11055 case "qvbrQualityLevel": 11056 if value != nil { 11057 jtv, ok := value.(json.Number) 11058 if !ok { 11059 return fmt.Errorf("expected __integerMin1Max10 to be json.Number, got %T instead", value) 11060 } 11061 i64, err := jtv.Int64() 11062 if err != nil { 11063 return err 11064 } 11065 sv.QvbrQualityLevel = int32(i64) 11066 } 11067 11068 case "qvbrQualityLevelFineTune": 11069 if value != nil { 11070 switch jtv := value.(type) { 11071 case json.Number: 11072 f64, err := jtv.Float64() 11073 if err != nil { 11074 return err 11075 } 11076 sv.QvbrQualityLevelFineTune = f64 11077 11078 case string: 11079 var f64 float64 11080 switch { 11081 case strings.EqualFold(jtv, "NaN"): 11082 f64 = math.NaN() 11083 11084 case strings.EqualFold(jtv, "Infinity"): 11085 f64 = math.Inf(1) 11086 11087 case strings.EqualFold(jtv, "-Infinity"): 11088 f64 = math.Inf(-1) 11089 11090 default: 11091 return fmt.Errorf("unknown JSON number value: %s", jtv) 11092 11093 } 11094 sv.QvbrQualityLevelFineTune = f64 11095 11096 default: 11097 return fmt.Errorf("expected __doubleMin0Max1 to be a JSON Number, got %T instead", value) 11098 11099 } 11100 } 11101 11102 default: 11103 _, _ = key, value 11104 11105 } 11106 } 11107 *v = sv 11108 return nil 11109} 11110 11111func awsRestjson1_deserializeDocumentH265Settings(v **types.H265Settings, value interface{}) error { 11112 if v == nil { 11113 return fmt.Errorf("unexpected nil of type %T", v) 11114 } 11115 if value == nil { 11116 return nil 11117 } 11118 11119 shape, ok := value.(map[string]interface{}) 11120 if !ok { 11121 return fmt.Errorf("unexpected JSON type %v", value) 11122 } 11123 11124 var sv *types.H265Settings 11125 if *v == nil { 11126 sv = &types.H265Settings{} 11127 } else { 11128 sv = *v 11129 } 11130 11131 for key, value := range shape { 11132 switch key { 11133 case "adaptiveQuantization": 11134 if value != nil { 11135 jtv, ok := value.(string) 11136 if !ok { 11137 return fmt.Errorf("expected H265AdaptiveQuantization to be of type string, got %T instead", value) 11138 } 11139 sv.AdaptiveQuantization = types.H265AdaptiveQuantization(jtv) 11140 } 11141 11142 case "alternateTransferFunctionSei": 11143 if value != nil { 11144 jtv, ok := value.(string) 11145 if !ok { 11146 return fmt.Errorf("expected H265AlternateTransferFunctionSei to be of type string, got %T instead", value) 11147 } 11148 sv.AlternateTransferFunctionSei = types.H265AlternateTransferFunctionSei(jtv) 11149 } 11150 11151 case "bitrate": 11152 if value != nil { 11153 jtv, ok := value.(json.Number) 11154 if !ok { 11155 return fmt.Errorf("expected __integerMin1000Max1466400000 to be json.Number, got %T instead", value) 11156 } 11157 i64, err := jtv.Int64() 11158 if err != nil { 11159 return err 11160 } 11161 sv.Bitrate = int32(i64) 11162 } 11163 11164 case "codecLevel": 11165 if value != nil { 11166 jtv, ok := value.(string) 11167 if !ok { 11168 return fmt.Errorf("expected H265CodecLevel to be of type string, got %T instead", value) 11169 } 11170 sv.CodecLevel = types.H265CodecLevel(jtv) 11171 } 11172 11173 case "codecProfile": 11174 if value != nil { 11175 jtv, ok := value.(string) 11176 if !ok { 11177 return fmt.Errorf("expected H265CodecProfile to be of type string, got %T instead", value) 11178 } 11179 sv.CodecProfile = types.H265CodecProfile(jtv) 11180 } 11181 11182 case "dynamicSubGop": 11183 if value != nil { 11184 jtv, ok := value.(string) 11185 if !ok { 11186 return fmt.Errorf("expected H265DynamicSubGop to be of type string, got %T instead", value) 11187 } 11188 sv.DynamicSubGop = types.H265DynamicSubGop(jtv) 11189 } 11190 11191 case "flickerAdaptiveQuantization": 11192 if value != nil { 11193 jtv, ok := value.(string) 11194 if !ok { 11195 return fmt.Errorf("expected H265FlickerAdaptiveQuantization to be of type string, got %T instead", value) 11196 } 11197 sv.FlickerAdaptiveQuantization = types.H265FlickerAdaptiveQuantization(jtv) 11198 } 11199 11200 case "framerateControl": 11201 if value != nil { 11202 jtv, ok := value.(string) 11203 if !ok { 11204 return fmt.Errorf("expected H265FramerateControl to be of type string, got %T instead", value) 11205 } 11206 sv.FramerateControl = types.H265FramerateControl(jtv) 11207 } 11208 11209 case "framerateConversionAlgorithm": 11210 if value != nil { 11211 jtv, ok := value.(string) 11212 if !ok { 11213 return fmt.Errorf("expected H265FramerateConversionAlgorithm to be of type string, got %T instead", value) 11214 } 11215 sv.FramerateConversionAlgorithm = types.H265FramerateConversionAlgorithm(jtv) 11216 } 11217 11218 case "framerateDenominator": 11219 if value != nil { 11220 jtv, ok := value.(json.Number) 11221 if !ok { 11222 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 11223 } 11224 i64, err := jtv.Int64() 11225 if err != nil { 11226 return err 11227 } 11228 sv.FramerateDenominator = int32(i64) 11229 } 11230 11231 case "framerateNumerator": 11232 if value != nil { 11233 jtv, ok := value.(json.Number) 11234 if !ok { 11235 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 11236 } 11237 i64, err := jtv.Int64() 11238 if err != nil { 11239 return err 11240 } 11241 sv.FramerateNumerator = int32(i64) 11242 } 11243 11244 case "gopBReference": 11245 if value != nil { 11246 jtv, ok := value.(string) 11247 if !ok { 11248 return fmt.Errorf("expected H265GopBReference to be of type string, got %T instead", value) 11249 } 11250 sv.GopBReference = types.H265GopBReference(jtv) 11251 } 11252 11253 case "gopClosedCadence": 11254 if value != nil { 11255 jtv, ok := value.(json.Number) 11256 if !ok { 11257 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 11258 } 11259 i64, err := jtv.Int64() 11260 if err != nil { 11261 return err 11262 } 11263 sv.GopClosedCadence = int32(i64) 11264 } 11265 11266 case "gopSize": 11267 if value != nil { 11268 switch jtv := value.(type) { 11269 case json.Number: 11270 f64, err := jtv.Float64() 11271 if err != nil { 11272 return err 11273 } 11274 sv.GopSize = f64 11275 11276 case string: 11277 var f64 float64 11278 switch { 11279 case strings.EqualFold(jtv, "NaN"): 11280 f64 = math.NaN() 11281 11282 case strings.EqualFold(jtv, "Infinity"): 11283 f64 = math.Inf(1) 11284 11285 case strings.EqualFold(jtv, "-Infinity"): 11286 f64 = math.Inf(-1) 11287 11288 default: 11289 return fmt.Errorf("unknown JSON number value: %s", jtv) 11290 11291 } 11292 sv.GopSize = f64 11293 11294 default: 11295 return fmt.Errorf("expected __doubleMin0 to be a JSON Number, got %T instead", value) 11296 11297 } 11298 } 11299 11300 case "gopSizeUnits": 11301 if value != nil { 11302 jtv, ok := value.(string) 11303 if !ok { 11304 return fmt.Errorf("expected H265GopSizeUnits to be of type string, got %T instead", value) 11305 } 11306 sv.GopSizeUnits = types.H265GopSizeUnits(jtv) 11307 } 11308 11309 case "hrdBufferInitialFillPercentage": 11310 if value != nil { 11311 jtv, ok := value.(json.Number) 11312 if !ok { 11313 return fmt.Errorf("expected __integerMin0Max100 to be json.Number, got %T instead", value) 11314 } 11315 i64, err := jtv.Int64() 11316 if err != nil { 11317 return err 11318 } 11319 sv.HrdBufferInitialFillPercentage = int32(i64) 11320 } 11321 11322 case "hrdBufferSize": 11323 if value != nil { 11324 jtv, ok := value.(json.Number) 11325 if !ok { 11326 return fmt.Errorf("expected __integerMin0Max1466400000 to be json.Number, got %T instead", value) 11327 } 11328 i64, err := jtv.Int64() 11329 if err != nil { 11330 return err 11331 } 11332 sv.HrdBufferSize = int32(i64) 11333 } 11334 11335 case "interlaceMode": 11336 if value != nil { 11337 jtv, ok := value.(string) 11338 if !ok { 11339 return fmt.Errorf("expected H265InterlaceMode to be of type string, got %T instead", value) 11340 } 11341 sv.InterlaceMode = types.H265InterlaceMode(jtv) 11342 } 11343 11344 case "maxBitrate": 11345 if value != nil { 11346 jtv, ok := value.(json.Number) 11347 if !ok { 11348 return fmt.Errorf("expected __integerMin1000Max1466400000 to be json.Number, got %T instead", value) 11349 } 11350 i64, err := jtv.Int64() 11351 if err != nil { 11352 return err 11353 } 11354 sv.MaxBitrate = int32(i64) 11355 } 11356 11357 case "minIInterval": 11358 if value != nil { 11359 jtv, ok := value.(json.Number) 11360 if !ok { 11361 return fmt.Errorf("expected __integerMin0Max30 to be json.Number, got %T instead", value) 11362 } 11363 i64, err := jtv.Int64() 11364 if err != nil { 11365 return err 11366 } 11367 sv.MinIInterval = int32(i64) 11368 } 11369 11370 case "numberBFramesBetweenReferenceFrames": 11371 if value != nil { 11372 jtv, ok := value.(json.Number) 11373 if !ok { 11374 return fmt.Errorf("expected __integerMin0Max7 to be json.Number, got %T instead", value) 11375 } 11376 i64, err := jtv.Int64() 11377 if err != nil { 11378 return err 11379 } 11380 sv.NumberBFramesBetweenReferenceFrames = int32(i64) 11381 } 11382 11383 case "numberReferenceFrames": 11384 if value != nil { 11385 jtv, ok := value.(json.Number) 11386 if !ok { 11387 return fmt.Errorf("expected __integerMin1Max6 to be json.Number, got %T instead", value) 11388 } 11389 i64, err := jtv.Int64() 11390 if err != nil { 11391 return err 11392 } 11393 sv.NumberReferenceFrames = int32(i64) 11394 } 11395 11396 case "parControl": 11397 if value != nil { 11398 jtv, ok := value.(string) 11399 if !ok { 11400 return fmt.Errorf("expected H265ParControl to be of type string, got %T instead", value) 11401 } 11402 sv.ParControl = types.H265ParControl(jtv) 11403 } 11404 11405 case "parDenominator": 11406 if value != nil { 11407 jtv, ok := value.(json.Number) 11408 if !ok { 11409 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 11410 } 11411 i64, err := jtv.Int64() 11412 if err != nil { 11413 return err 11414 } 11415 sv.ParDenominator = int32(i64) 11416 } 11417 11418 case "parNumerator": 11419 if value != nil { 11420 jtv, ok := value.(json.Number) 11421 if !ok { 11422 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 11423 } 11424 i64, err := jtv.Int64() 11425 if err != nil { 11426 return err 11427 } 11428 sv.ParNumerator = int32(i64) 11429 } 11430 11431 case "qualityTuningLevel": 11432 if value != nil { 11433 jtv, ok := value.(string) 11434 if !ok { 11435 return fmt.Errorf("expected H265QualityTuningLevel to be of type string, got %T instead", value) 11436 } 11437 sv.QualityTuningLevel = types.H265QualityTuningLevel(jtv) 11438 } 11439 11440 case "qvbrSettings": 11441 if err := awsRestjson1_deserializeDocumentH265QvbrSettings(&sv.QvbrSettings, value); err != nil { 11442 return err 11443 } 11444 11445 case "rateControlMode": 11446 if value != nil { 11447 jtv, ok := value.(string) 11448 if !ok { 11449 return fmt.Errorf("expected H265RateControlMode to be of type string, got %T instead", value) 11450 } 11451 sv.RateControlMode = types.H265RateControlMode(jtv) 11452 } 11453 11454 case "sampleAdaptiveOffsetFilterMode": 11455 if value != nil { 11456 jtv, ok := value.(string) 11457 if !ok { 11458 return fmt.Errorf("expected H265SampleAdaptiveOffsetFilterMode to be of type string, got %T instead", value) 11459 } 11460 sv.SampleAdaptiveOffsetFilterMode = types.H265SampleAdaptiveOffsetFilterMode(jtv) 11461 } 11462 11463 case "scanTypeConversionMode": 11464 if value != nil { 11465 jtv, ok := value.(string) 11466 if !ok { 11467 return fmt.Errorf("expected H265ScanTypeConversionMode to be of type string, got %T instead", value) 11468 } 11469 sv.ScanTypeConversionMode = types.H265ScanTypeConversionMode(jtv) 11470 } 11471 11472 case "sceneChangeDetect": 11473 if value != nil { 11474 jtv, ok := value.(string) 11475 if !ok { 11476 return fmt.Errorf("expected H265SceneChangeDetect to be of type string, got %T instead", value) 11477 } 11478 sv.SceneChangeDetect = types.H265SceneChangeDetect(jtv) 11479 } 11480 11481 case "slices": 11482 if value != nil { 11483 jtv, ok := value.(json.Number) 11484 if !ok { 11485 return fmt.Errorf("expected __integerMin1Max32 to be json.Number, got %T instead", value) 11486 } 11487 i64, err := jtv.Int64() 11488 if err != nil { 11489 return err 11490 } 11491 sv.Slices = int32(i64) 11492 } 11493 11494 case "slowPal": 11495 if value != nil { 11496 jtv, ok := value.(string) 11497 if !ok { 11498 return fmt.Errorf("expected H265SlowPal to be of type string, got %T instead", value) 11499 } 11500 sv.SlowPal = types.H265SlowPal(jtv) 11501 } 11502 11503 case "spatialAdaptiveQuantization": 11504 if value != nil { 11505 jtv, ok := value.(string) 11506 if !ok { 11507 return fmt.Errorf("expected H265SpatialAdaptiveQuantization to be of type string, got %T instead", value) 11508 } 11509 sv.SpatialAdaptiveQuantization = types.H265SpatialAdaptiveQuantization(jtv) 11510 } 11511 11512 case "telecine": 11513 if value != nil { 11514 jtv, ok := value.(string) 11515 if !ok { 11516 return fmt.Errorf("expected H265Telecine to be of type string, got %T instead", value) 11517 } 11518 sv.Telecine = types.H265Telecine(jtv) 11519 } 11520 11521 case "temporalAdaptiveQuantization": 11522 if value != nil { 11523 jtv, ok := value.(string) 11524 if !ok { 11525 return fmt.Errorf("expected H265TemporalAdaptiveQuantization to be of type string, got %T instead", value) 11526 } 11527 sv.TemporalAdaptiveQuantization = types.H265TemporalAdaptiveQuantization(jtv) 11528 } 11529 11530 case "temporalIds": 11531 if value != nil { 11532 jtv, ok := value.(string) 11533 if !ok { 11534 return fmt.Errorf("expected H265TemporalIds to be of type string, got %T instead", value) 11535 } 11536 sv.TemporalIds = types.H265TemporalIds(jtv) 11537 } 11538 11539 case "tiles": 11540 if value != nil { 11541 jtv, ok := value.(string) 11542 if !ok { 11543 return fmt.Errorf("expected H265Tiles to be of type string, got %T instead", value) 11544 } 11545 sv.Tiles = types.H265Tiles(jtv) 11546 } 11547 11548 case "unregisteredSeiTimecode": 11549 if value != nil { 11550 jtv, ok := value.(string) 11551 if !ok { 11552 return fmt.Errorf("expected H265UnregisteredSeiTimecode to be of type string, got %T instead", value) 11553 } 11554 sv.UnregisteredSeiTimecode = types.H265UnregisteredSeiTimecode(jtv) 11555 } 11556 11557 case "writeMp4PackagingType": 11558 if value != nil { 11559 jtv, ok := value.(string) 11560 if !ok { 11561 return fmt.Errorf("expected H265WriteMp4PackagingType to be of type string, got %T instead", value) 11562 } 11563 sv.WriteMp4PackagingType = types.H265WriteMp4PackagingType(jtv) 11564 } 11565 11566 default: 11567 _, _ = key, value 11568 11569 } 11570 } 11571 *v = sv 11572 return nil 11573} 11574 11575func awsRestjson1_deserializeDocumentHdr10Metadata(v **types.Hdr10Metadata, value interface{}) error { 11576 if v == nil { 11577 return fmt.Errorf("unexpected nil of type %T", v) 11578 } 11579 if value == nil { 11580 return nil 11581 } 11582 11583 shape, ok := value.(map[string]interface{}) 11584 if !ok { 11585 return fmt.Errorf("unexpected JSON type %v", value) 11586 } 11587 11588 var sv *types.Hdr10Metadata 11589 if *v == nil { 11590 sv = &types.Hdr10Metadata{} 11591 } else { 11592 sv = *v 11593 } 11594 11595 for key, value := range shape { 11596 switch key { 11597 case "bluePrimaryX": 11598 if value != nil { 11599 jtv, ok := value.(json.Number) 11600 if !ok { 11601 return fmt.Errorf("expected __integerMin0Max50000 to be json.Number, got %T instead", value) 11602 } 11603 i64, err := jtv.Int64() 11604 if err != nil { 11605 return err 11606 } 11607 sv.BluePrimaryX = int32(i64) 11608 } 11609 11610 case "bluePrimaryY": 11611 if value != nil { 11612 jtv, ok := value.(json.Number) 11613 if !ok { 11614 return fmt.Errorf("expected __integerMin0Max50000 to be json.Number, got %T instead", value) 11615 } 11616 i64, err := jtv.Int64() 11617 if err != nil { 11618 return err 11619 } 11620 sv.BluePrimaryY = int32(i64) 11621 } 11622 11623 case "greenPrimaryX": 11624 if value != nil { 11625 jtv, ok := value.(json.Number) 11626 if !ok { 11627 return fmt.Errorf("expected __integerMin0Max50000 to be json.Number, got %T instead", value) 11628 } 11629 i64, err := jtv.Int64() 11630 if err != nil { 11631 return err 11632 } 11633 sv.GreenPrimaryX = int32(i64) 11634 } 11635 11636 case "greenPrimaryY": 11637 if value != nil { 11638 jtv, ok := value.(json.Number) 11639 if !ok { 11640 return fmt.Errorf("expected __integerMin0Max50000 to be json.Number, got %T instead", value) 11641 } 11642 i64, err := jtv.Int64() 11643 if err != nil { 11644 return err 11645 } 11646 sv.GreenPrimaryY = int32(i64) 11647 } 11648 11649 case "maxContentLightLevel": 11650 if value != nil { 11651 jtv, ok := value.(json.Number) 11652 if !ok { 11653 return fmt.Errorf("expected __integerMin0Max65535 to be json.Number, got %T instead", value) 11654 } 11655 i64, err := jtv.Int64() 11656 if err != nil { 11657 return err 11658 } 11659 sv.MaxContentLightLevel = int32(i64) 11660 } 11661 11662 case "maxFrameAverageLightLevel": 11663 if value != nil { 11664 jtv, ok := value.(json.Number) 11665 if !ok { 11666 return fmt.Errorf("expected __integerMin0Max65535 to be json.Number, got %T instead", value) 11667 } 11668 i64, err := jtv.Int64() 11669 if err != nil { 11670 return err 11671 } 11672 sv.MaxFrameAverageLightLevel = int32(i64) 11673 } 11674 11675 case "maxLuminance": 11676 if value != nil { 11677 jtv, ok := value.(json.Number) 11678 if !ok { 11679 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 11680 } 11681 i64, err := jtv.Int64() 11682 if err != nil { 11683 return err 11684 } 11685 sv.MaxLuminance = int32(i64) 11686 } 11687 11688 case "minLuminance": 11689 if value != nil { 11690 jtv, ok := value.(json.Number) 11691 if !ok { 11692 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 11693 } 11694 i64, err := jtv.Int64() 11695 if err != nil { 11696 return err 11697 } 11698 sv.MinLuminance = int32(i64) 11699 } 11700 11701 case "redPrimaryX": 11702 if value != nil { 11703 jtv, ok := value.(json.Number) 11704 if !ok { 11705 return fmt.Errorf("expected __integerMin0Max50000 to be json.Number, got %T instead", value) 11706 } 11707 i64, err := jtv.Int64() 11708 if err != nil { 11709 return err 11710 } 11711 sv.RedPrimaryX = int32(i64) 11712 } 11713 11714 case "redPrimaryY": 11715 if value != nil { 11716 jtv, ok := value.(json.Number) 11717 if !ok { 11718 return fmt.Errorf("expected __integerMin0Max50000 to be json.Number, got %T instead", value) 11719 } 11720 i64, err := jtv.Int64() 11721 if err != nil { 11722 return err 11723 } 11724 sv.RedPrimaryY = int32(i64) 11725 } 11726 11727 case "whitePointX": 11728 if value != nil { 11729 jtv, ok := value.(json.Number) 11730 if !ok { 11731 return fmt.Errorf("expected __integerMin0Max50000 to be json.Number, got %T instead", value) 11732 } 11733 i64, err := jtv.Int64() 11734 if err != nil { 11735 return err 11736 } 11737 sv.WhitePointX = int32(i64) 11738 } 11739 11740 case "whitePointY": 11741 if value != nil { 11742 jtv, ok := value.(json.Number) 11743 if !ok { 11744 return fmt.Errorf("expected __integerMin0Max50000 to be json.Number, got %T instead", value) 11745 } 11746 i64, err := jtv.Int64() 11747 if err != nil { 11748 return err 11749 } 11750 sv.WhitePointY = int32(i64) 11751 } 11752 11753 default: 11754 _, _ = key, value 11755 11756 } 11757 } 11758 *v = sv 11759 return nil 11760} 11761 11762func awsRestjson1_deserializeDocumentHdr10Plus(v **types.Hdr10Plus, value interface{}) error { 11763 if v == nil { 11764 return fmt.Errorf("unexpected nil of type %T", v) 11765 } 11766 if value == nil { 11767 return nil 11768 } 11769 11770 shape, ok := value.(map[string]interface{}) 11771 if !ok { 11772 return fmt.Errorf("unexpected JSON type %v", value) 11773 } 11774 11775 var sv *types.Hdr10Plus 11776 if *v == nil { 11777 sv = &types.Hdr10Plus{} 11778 } else { 11779 sv = *v 11780 } 11781 11782 for key, value := range shape { 11783 switch key { 11784 case "masteringMonitorNits": 11785 if value != nil { 11786 jtv, ok := value.(json.Number) 11787 if !ok { 11788 return fmt.Errorf("expected __integerMin0Max4000 to be json.Number, got %T instead", value) 11789 } 11790 i64, err := jtv.Int64() 11791 if err != nil { 11792 return err 11793 } 11794 sv.MasteringMonitorNits = int32(i64) 11795 } 11796 11797 case "targetMonitorNits": 11798 if value != nil { 11799 jtv, ok := value.(json.Number) 11800 if !ok { 11801 return fmt.Errorf("expected __integerMin0Max4000 to be json.Number, got %T instead", value) 11802 } 11803 i64, err := jtv.Int64() 11804 if err != nil { 11805 return err 11806 } 11807 sv.TargetMonitorNits = int32(i64) 11808 } 11809 11810 default: 11811 _, _ = key, value 11812 11813 } 11814 } 11815 *v = sv 11816 return nil 11817} 11818 11819func awsRestjson1_deserializeDocumentHlsAdditionalManifest(v **types.HlsAdditionalManifest, value interface{}) error { 11820 if v == nil { 11821 return fmt.Errorf("unexpected nil of type %T", v) 11822 } 11823 if value == nil { 11824 return nil 11825 } 11826 11827 shape, ok := value.(map[string]interface{}) 11828 if !ok { 11829 return fmt.Errorf("unexpected JSON type %v", value) 11830 } 11831 11832 var sv *types.HlsAdditionalManifest 11833 if *v == nil { 11834 sv = &types.HlsAdditionalManifest{} 11835 } else { 11836 sv = *v 11837 } 11838 11839 for key, value := range shape { 11840 switch key { 11841 case "manifestNameModifier": 11842 if value != nil { 11843 jtv, ok := value.(string) 11844 if !ok { 11845 return fmt.Errorf("expected __stringMin1 to be of type string, got %T instead", value) 11846 } 11847 sv.ManifestNameModifier = ptr.String(jtv) 11848 } 11849 11850 case "selectedOutputs": 11851 if err := awsRestjson1_deserializeDocument__listOf__stringMin1(&sv.SelectedOutputs, value); err != nil { 11852 return err 11853 } 11854 11855 default: 11856 _, _ = key, value 11857 11858 } 11859 } 11860 *v = sv 11861 return nil 11862} 11863 11864func awsRestjson1_deserializeDocumentHlsCaptionLanguageMapping(v **types.HlsCaptionLanguageMapping, value interface{}) error { 11865 if v == nil { 11866 return fmt.Errorf("unexpected nil of type %T", v) 11867 } 11868 if value == nil { 11869 return nil 11870 } 11871 11872 shape, ok := value.(map[string]interface{}) 11873 if !ok { 11874 return fmt.Errorf("unexpected JSON type %v", value) 11875 } 11876 11877 var sv *types.HlsCaptionLanguageMapping 11878 if *v == nil { 11879 sv = &types.HlsCaptionLanguageMapping{} 11880 } else { 11881 sv = *v 11882 } 11883 11884 for key, value := range shape { 11885 switch key { 11886 case "captionChannel": 11887 if value != nil { 11888 jtv, ok := value.(json.Number) 11889 if !ok { 11890 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 11891 } 11892 i64, err := jtv.Int64() 11893 if err != nil { 11894 return err 11895 } 11896 sv.CaptionChannel = int32(i64) 11897 } 11898 11899 case "customLanguageCode": 11900 if value != nil { 11901 jtv, ok := value.(string) 11902 if !ok { 11903 return fmt.Errorf("expected __stringMin3Max3PatternAZaZ3 to be of type string, got %T instead", value) 11904 } 11905 sv.CustomLanguageCode = ptr.String(jtv) 11906 } 11907 11908 case "languageCode": 11909 if value != nil { 11910 jtv, ok := value.(string) 11911 if !ok { 11912 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 11913 } 11914 sv.LanguageCode = types.LanguageCode(jtv) 11915 } 11916 11917 case "languageDescription": 11918 if value != nil { 11919 jtv, ok := value.(string) 11920 if !ok { 11921 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11922 } 11923 sv.LanguageDescription = ptr.String(jtv) 11924 } 11925 11926 default: 11927 _, _ = key, value 11928 11929 } 11930 } 11931 *v = sv 11932 return nil 11933} 11934 11935func awsRestjson1_deserializeDocumentHlsEncryptionSettings(v **types.HlsEncryptionSettings, value interface{}) error { 11936 if v == nil { 11937 return fmt.Errorf("unexpected nil of type %T", v) 11938 } 11939 if value == nil { 11940 return nil 11941 } 11942 11943 shape, ok := value.(map[string]interface{}) 11944 if !ok { 11945 return fmt.Errorf("unexpected JSON type %v", value) 11946 } 11947 11948 var sv *types.HlsEncryptionSettings 11949 if *v == nil { 11950 sv = &types.HlsEncryptionSettings{} 11951 } else { 11952 sv = *v 11953 } 11954 11955 for key, value := range shape { 11956 switch key { 11957 case "constantInitializationVector": 11958 if value != nil { 11959 jtv, ok := value.(string) 11960 if !ok { 11961 return fmt.Errorf("expected __stringMin32Max32Pattern09aFAF32 to be of type string, got %T instead", value) 11962 } 11963 sv.ConstantInitializationVector = ptr.String(jtv) 11964 } 11965 11966 case "encryptionMethod": 11967 if value != nil { 11968 jtv, ok := value.(string) 11969 if !ok { 11970 return fmt.Errorf("expected HlsEncryptionType to be of type string, got %T instead", value) 11971 } 11972 sv.EncryptionMethod = types.HlsEncryptionType(jtv) 11973 } 11974 11975 case "initializationVectorInManifest": 11976 if value != nil { 11977 jtv, ok := value.(string) 11978 if !ok { 11979 return fmt.Errorf("expected HlsInitializationVectorInManifest to be of type string, got %T instead", value) 11980 } 11981 sv.InitializationVectorInManifest = types.HlsInitializationVectorInManifest(jtv) 11982 } 11983 11984 case "offlineEncrypted": 11985 if value != nil { 11986 jtv, ok := value.(string) 11987 if !ok { 11988 return fmt.Errorf("expected HlsOfflineEncrypted to be of type string, got %T instead", value) 11989 } 11990 sv.OfflineEncrypted = types.HlsOfflineEncrypted(jtv) 11991 } 11992 11993 case "spekeKeyProvider": 11994 if err := awsRestjson1_deserializeDocumentSpekeKeyProvider(&sv.SpekeKeyProvider, value); err != nil { 11995 return err 11996 } 11997 11998 case "staticKeyProvider": 11999 if err := awsRestjson1_deserializeDocumentStaticKeyProvider(&sv.StaticKeyProvider, value); err != nil { 12000 return err 12001 } 12002 12003 case "type": 12004 if value != nil { 12005 jtv, ok := value.(string) 12006 if !ok { 12007 return fmt.Errorf("expected HlsKeyProviderType to be of type string, got %T instead", value) 12008 } 12009 sv.Type = types.HlsKeyProviderType(jtv) 12010 } 12011 12012 default: 12013 _, _ = key, value 12014 12015 } 12016 } 12017 *v = sv 12018 return nil 12019} 12020 12021func awsRestjson1_deserializeDocumentHlsGroupSettings(v **types.HlsGroupSettings, value interface{}) error { 12022 if v == nil { 12023 return fmt.Errorf("unexpected nil of type %T", v) 12024 } 12025 if value == nil { 12026 return nil 12027 } 12028 12029 shape, ok := value.(map[string]interface{}) 12030 if !ok { 12031 return fmt.Errorf("unexpected JSON type %v", value) 12032 } 12033 12034 var sv *types.HlsGroupSettings 12035 if *v == nil { 12036 sv = &types.HlsGroupSettings{} 12037 } else { 12038 sv = *v 12039 } 12040 12041 for key, value := range shape { 12042 switch key { 12043 case "additionalManifests": 12044 if err := awsRestjson1_deserializeDocument__listOfHlsAdditionalManifest(&sv.AdditionalManifests, value); err != nil { 12045 return err 12046 } 12047 12048 case "adMarkers": 12049 if err := awsRestjson1_deserializeDocument__listOfHlsAdMarkers(&sv.AdMarkers, value); err != nil { 12050 return err 12051 } 12052 12053 case "audioOnlyHeader": 12054 if value != nil { 12055 jtv, ok := value.(string) 12056 if !ok { 12057 return fmt.Errorf("expected HlsAudioOnlyHeader to be of type string, got %T instead", value) 12058 } 12059 sv.AudioOnlyHeader = types.HlsAudioOnlyHeader(jtv) 12060 } 12061 12062 case "baseUrl": 12063 if value != nil { 12064 jtv, ok := value.(string) 12065 if !ok { 12066 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12067 } 12068 sv.BaseUrl = ptr.String(jtv) 12069 } 12070 12071 case "captionLanguageMappings": 12072 if err := awsRestjson1_deserializeDocument__listOfHlsCaptionLanguageMapping(&sv.CaptionLanguageMappings, value); err != nil { 12073 return err 12074 } 12075 12076 case "captionLanguageSetting": 12077 if value != nil { 12078 jtv, ok := value.(string) 12079 if !ok { 12080 return fmt.Errorf("expected HlsCaptionLanguageSetting to be of type string, got %T instead", value) 12081 } 12082 sv.CaptionLanguageSetting = types.HlsCaptionLanguageSetting(jtv) 12083 } 12084 12085 case "clientCache": 12086 if value != nil { 12087 jtv, ok := value.(string) 12088 if !ok { 12089 return fmt.Errorf("expected HlsClientCache to be of type string, got %T instead", value) 12090 } 12091 sv.ClientCache = types.HlsClientCache(jtv) 12092 } 12093 12094 case "codecSpecification": 12095 if value != nil { 12096 jtv, ok := value.(string) 12097 if !ok { 12098 return fmt.Errorf("expected HlsCodecSpecification to be of type string, got %T instead", value) 12099 } 12100 sv.CodecSpecification = types.HlsCodecSpecification(jtv) 12101 } 12102 12103 case "destination": 12104 if value != nil { 12105 jtv, ok := value.(string) 12106 if !ok { 12107 return fmt.Errorf("expected __stringPatternS3 to be of type string, got %T instead", value) 12108 } 12109 sv.Destination = ptr.String(jtv) 12110 } 12111 12112 case "destinationSettings": 12113 if err := awsRestjson1_deserializeDocumentDestinationSettings(&sv.DestinationSettings, value); err != nil { 12114 return err 12115 } 12116 12117 case "directoryStructure": 12118 if value != nil { 12119 jtv, ok := value.(string) 12120 if !ok { 12121 return fmt.Errorf("expected HlsDirectoryStructure to be of type string, got %T instead", value) 12122 } 12123 sv.DirectoryStructure = types.HlsDirectoryStructure(jtv) 12124 } 12125 12126 case "encryption": 12127 if err := awsRestjson1_deserializeDocumentHlsEncryptionSettings(&sv.Encryption, value); err != nil { 12128 return err 12129 } 12130 12131 case "imageBasedTrickPlay": 12132 if value != nil { 12133 jtv, ok := value.(string) 12134 if !ok { 12135 return fmt.Errorf("expected HlsImageBasedTrickPlay to be of type string, got %T instead", value) 12136 } 12137 sv.ImageBasedTrickPlay = types.HlsImageBasedTrickPlay(jtv) 12138 } 12139 12140 case "manifestCompression": 12141 if value != nil { 12142 jtv, ok := value.(string) 12143 if !ok { 12144 return fmt.Errorf("expected HlsManifestCompression to be of type string, got %T instead", value) 12145 } 12146 sv.ManifestCompression = types.HlsManifestCompression(jtv) 12147 } 12148 12149 case "manifestDurationFormat": 12150 if value != nil { 12151 jtv, ok := value.(string) 12152 if !ok { 12153 return fmt.Errorf("expected HlsManifestDurationFormat to be of type string, got %T instead", value) 12154 } 12155 sv.ManifestDurationFormat = types.HlsManifestDurationFormat(jtv) 12156 } 12157 12158 case "minFinalSegmentLength": 12159 if value != nil { 12160 switch jtv := value.(type) { 12161 case json.Number: 12162 f64, err := jtv.Float64() 12163 if err != nil { 12164 return err 12165 } 12166 sv.MinFinalSegmentLength = f64 12167 12168 case string: 12169 var f64 float64 12170 switch { 12171 case strings.EqualFold(jtv, "NaN"): 12172 f64 = math.NaN() 12173 12174 case strings.EqualFold(jtv, "Infinity"): 12175 f64 = math.Inf(1) 12176 12177 case strings.EqualFold(jtv, "-Infinity"): 12178 f64 = math.Inf(-1) 12179 12180 default: 12181 return fmt.Errorf("unknown JSON number value: %s", jtv) 12182 12183 } 12184 sv.MinFinalSegmentLength = f64 12185 12186 default: 12187 return fmt.Errorf("expected __doubleMin0Max2147483647 to be a JSON Number, got %T instead", value) 12188 12189 } 12190 } 12191 12192 case "minSegmentLength": 12193 if value != nil { 12194 jtv, ok := value.(json.Number) 12195 if !ok { 12196 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 12197 } 12198 i64, err := jtv.Int64() 12199 if err != nil { 12200 return err 12201 } 12202 sv.MinSegmentLength = int32(i64) 12203 } 12204 12205 case "outputSelection": 12206 if value != nil { 12207 jtv, ok := value.(string) 12208 if !ok { 12209 return fmt.Errorf("expected HlsOutputSelection to be of type string, got %T instead", value) 12210 } 12211 sv.OutputSelection = types.HlsOutputSelection(jtv) 12212 } 12213 12214 case "programDateTime": 12215 if value != nil { 12216 jtv, ok := value.(string) 12217 if !ok { 12218 return fmt.Errorf("expected HlsProgramDateTime to be of type string, got %T instead", value) 12219 } 12220 sv.ProgramDateTime = types.HlsProgramDateTime(jtv) 12221 } 12222 12223 case "programDateTimePeriod": 12224 if value != nil { 12225 jtv, ok := value.(json.Number) 12226 if !ok { 12227 return fmt.Errorf("expected __integerMin0Max3600 to be json.Number, got %T instead", value) 12228 } 12229 i64, err := jtv.Int64() 12230 if err != nil { 12231 return err 12232 } 12233 sv.ProgramDateTimePeriod = int32(i64) 12234 } 12235 12236 case "segmentControl": 12237 if value != nil { 12238 jtv, ok := value.(string) 12239 if !ok { 12240 return fmt.Errorf("expected HlsSegmentControl to be of type string, got %T instead", value) 12241 } 12242 sv.SegmentControl = types.HlsSegmentControl(jtv) 12243 } 12244 12245 case "segmentLength": 12246 if value != nil { 12247 jtv, ok := value.(json.Number) 12248 if !ok { 12249 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 12250 } 12251 i64, err := jtv.Int64() 12252 if err != nil { 12253 return err 12254 } 12255 sv.SegmentLength = int32(i64) 12256 } 12257 12258 case "segmentLengthControl": 12259 if value != nil { 12260 jtv, ok := value.(string) 12261 if !ok { 12262 return fmt.Errorf("expected HlsSegmentLengthControl to be of type string, got %T instead", value) 12263 } 12264 sv.SegmentLengthControl = types.HlsSegmentLengthControl(jtv) 12265 } 12266 12267 case "segmentsPerSubdirectory": 12268 if value != nil { 12269 jtv, ok := value.(json.Number) 12270 if !ok { 12271 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 12272 } 12273 i64, err := jtv.Int64() 12274 if err != nil { 12275 return err 12276 } 12277 sv.SegmentsPerSubdirectory = int32(i64) 12278 } 12279 12280 case "streamInfResolution": 12281 if value != nil { 12282 jtv, ok := value.(string) 12283 if !ok { 12284 return fmt.Errorf("expected HlsStreamInfResolution to be of type string, got %T instead", value) 12285 } 12286 sv.StreamInfResolution = types.HlsStreamInfResolution(jtv) 12287 } 12288 12289 case "targetDurationCompatibilityMode": 12290 if value != nil { 12291 jtv, ok := value.(string) 12292 if !ok { 12293 return fmt.Errorf("expected HlsTargetDurationCompatibilityMode to be of type string, got %T instead", value) 12294 } 12295 sv.TargetDurationCompatibilityMode = types.HlsTargetDurationCompatibilityMode(jtv) 12296 } 12297 12298 case "timedMetadataId3Frame": 12299 if value != nil { 12300 jtv, ok := value.(string) 12301 if !ok { 12302 return fmt.Errorf("expected HlsTimedMetadataId3Frame to be of type string, got %T instead", value) 12303 } 12304 sv.TimedMetadataId3Frame = types.HlsTimedMetadataId3Frame(jtv) 12305 } 12306 12307 case "timedMetadataId3Period": 12308 if value != nil { 12309 jtv, ok := value.(json.Number) 12310 if !ok { 12311 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 12312 } 12313 i64, err := jtv.Int64() 12314 if err != nil { 12315 return err 12316 } 12317 sv.TimedMetadataId3Period = int32(i64) 12318 } 12319 12320 case "timestampDeltaMilliseconds": 12321 if value != nil { 12322 jtv, ok := value.(json.Number) 12323 if !ok { 12324 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 12325 } 12326 i64, err := jtv.Int64() 12327 if err != nil { 12328 return err 12329 } 12330 sv.TimestampDeltaMilliseconds = int32(i64) 12331 } 12332 12333 default: 12334 _, _ = key, value 12335 12336 } 12337 } 12338 *v = sv 12339 return nil 12340} 12341 12342func awsRestjson1_deserializeDocumentHlsRenditionGroupSettings(v **types.HlsRenditionGroupSettings, value interface{}) error { 12343 if v == nil { 12344 return fmt.Errorf("unexpected nil of type %T", v) 12345 } 12346 if value == nil { 12347 return nil 12348 } 12349 12350 shape, ok := value.(map[string]interface{}) 12351 if !ok { 12352 return fmt.Errorf("unexpected JSON type %v", value) 12353 } 12354 12355 var sv *types.HlsRenditionGroupSettings 12356 if *v == nil { 12357 sv = &types.HlsRenditionGroupSettings{} 12358 } else { 12359 sv = *v 12360 } 12361 12362 for key, value := range shape { 12363 switch key { 12364 case "renditionGroupId": 12365 if value != nil { 12366 jtv, ok := value.(string) 12367 if !ok { 12368 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12369 } 12370 sv.RenditionGroupId = ptr.String(jtv) 12371 } 12372 12373 case "renditionLanguageCode": 12374 if value != nil { 12375 jtv, ok := value.(string) 12376 if !ok { 12377 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 12378 } 12379 sv.RenditionLanguageCode = types.LanguageCode(jtv) 12380 } 12381 12382 case "renditionName": 12383 if value != nil { 12384 jtv, ok := value.(string) 12385 if !ok { 12386 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12387 } 12388 sv.RenditionName = ptr.String(jtv) 12389 } 12390 12391 default: 12392 _, _ = key, value 12393 12394 } 12395 } 12396 *v = sv 12397 return nil 12398} 12399 12400func awsRestjson1_deserializeDocumentHlsSettings(v **types.HlsSettings, value interface{}) error { 12401 if v == nil { 12402 return fmt.Errorf("unexpected nil of type %T", v) 12403 } 12404 if value == nil { 12405 return nil 12406 } 12407 12408 shape, ok := value.(map[string]interface{}) 12409 if !ok { 12410 return fmt.Errorf("unexpected JSON type %v", value) 12411 } 12412 12413 var sv *types.HlsSettings 12414 if *v == nil { 12415 sv = &types.HlsSettings{} 12416 } else { 12417 sv = *v 12418 } 12419 12420 for key, value := range shape { 12421 switch key { 12422 case "audioGroupId": 12423 if value != nil { 12424 jtv, ok := value.(string) 12425 if !ok { 12426 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12427 } 12428 sv.AudioGroupId = ptr.String(jtv) 12429 } 12430 12431 case "audioOnlyContainer": 12432 if value != nil { 12433 jtv, ok := value.(string) 12434 if !ok { 12435 return fmt.Errorf("expected HlsAudioOnlyContainer to be of type string, got %T instead", value) 12436 } 12437 sv.AudioOnlyContainer = types.HlsAudioOnlyContainer(jtv) 12438 } 12439 12440 case "audioRenditionSets": 12441 if value != nil { 12442 jtv, ok := value.(string) 12443 if !ok { 12444 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12445 } 12446 sv.AudioRenditionSets = ptr.String(jtv) 12447 } 12448 12449 case "audioTrackType": 12450 if value != nil { 12451 jtv, ok := value.(string) 12452 if !ok { 12453 return fmt.Errorf("expected HlsAudioTrackType to be of type string, got %T instead", value) 12454 } 12455 sv.AudioTrackType = types.HlsAudioTrackType(jtv) 12456 } 12457 12458 case "descriptiveVideoServiceFlag": 12459 if value != nil { 12460 jtv, ok := value.(string) 12461 if !ok { 12462 return fmt.Errorf("expected HlsDescriptiveVideoServiceFlag to be of type string, got %T instead", value) 12463 } 12464 sv.DescriptiveVideoServiceFlag = types.HlsDescriptiveVideoServiceFlag(jtv) 12465 } 12466 12467 case "iFrameOnlyManifest": 12468 if value != nil { 12469 jtv, ok := value.(string) 12470 if !ok { 12471 return fmt.Errorf("expected HlsIFrameOnlyManifest to be of type string, got %T instead", value) 12472 } 12473 sv.IFrameOnlyManifest = types.HlsIFrameOnlyManifest(jtv) 12474 } 12475 12476 case "segmentModifier": 12477 if value != nil { 12478 jtv, ok := value.(string) 12479 if !ok { 12480 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12481 } 12482 sv.SegmentModifier = ptr.String(jtv) 12483 } 12484 12485 default: 12486 _, _ = key, value 12487 12488 } 12489 } 12490 *v = sv 12491 return nil 12492} 12493 12494func awsRestjson1_deserializeDocumentHopDestination(v **types.HopDestination, value interface{}) error { 12495 if v == nil { 12496 return fmt.Errorf("unexpected nil of type %T", v) 12497 } 12498 if value == nil { 12499 return nil 12500 } 12501 12502 shape, ok := value.(map[string]interface{}) 12503 if !ok { 12504 return fmt.Errorf("unexpected JSON type %v", value) 12505 } 12506 12507 var sv *types.HopDestination 12508 if *v == nil { 12509 sv = &types.HopDestination{} 12510 } else { 12511 sv = *v 12512 } 12513 12514 for key, value := range shape { 12515 switch key { 12516 case "priority": 12517 if value != nil { 12518 jtv, ok := value.(json.Number) 12519 if !ok { 12520 return fmt.Errorf("expected __integerMinNegative50Max50 to be json.Number, got %T instead", value) 12521 } 12522 i64, err := jtv.Int64() 12523 if err != nil { 12524 return err 12525 } 12526 sv.Priority = int32(i64) 12527 } 12528 12529 case "queue": 12530 if value != nil { 12531 jtv, ok := value.(string) 12532 if !ok { 12533 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12534 } 12535 sv.Queue = ptr.String(jtv) 12536 } 12537 12538 case "waitMinutes": 12539 if value != nil { 12540 jtv, ok := value.(json.Number) 12541 if !ok { 12542 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 12543 } 12544 i64, err := jtv.Int64() 12545 if err != nil { 12546 return err 12547 } 12548 sv.WaitMinutes = int32(i64) 12549 } 12550 12551 default: 12552 _, _ = key, value 12553 12554 } 12555 } 12556 *v = sv 12557 return nil 12558} 12559 12560func awsRestjson1_deserializeDocumentId3Insertion(v **types.Id3Insertion, value interface{}) error { 12561 if v == nil { 12562 return fmt.Errorf("unexpected nil of type %T", v) 12563 } 12564 if value == nil { 12565 return nil 12566 } 12567 12568 shape, ok := value.(map[string]interface{}) 12569 if !ok { 12570 return fmt.Errorf("unexpected JSON type %v", value) 12571 } 12572 12573 var sv *types.Id3Insertion 12574 if *v == nil { 12575 sv = &types.Id3Insertion{} 12576 } else { 12577 sv = *v 12578 } 12579 12580 for key, value := range shape { 12581 switch key { 12582 case "id3": 12583 if value != nil { 12584 jtv, ok := value.(string) 12585 if !ok { 12586 return fmt.Errorf("expected __stringPatternAZaZ0902 to be of type string, got %T instead", value) 12587 } 12588 sv.Id3 = ptr.String(jtv) 12589 } 12590 12591 case "timecode": 12592 if value != nil { 12593 jtv, ok := value.(string) 12594 if !ok { 12595 return fmt.Errorf("expected __stringPattern010920405090509092 to be of type string, got %T instead", value) 12596 } 12597 sv.Timecode = ptr.String(jtv) 12598 } 12599 12600 default: 12601 _, _ = key, value 12602 12603 } 12604 } 12605 *v = sv 12606 return nil 12607} 12608 12609func awsRestjson1_deserializeDocumentImageInserter(v **types.ImageInserter, value interface{}) error { 12610 if v == nil { 12611 return fmt.Errorf("unexpected nil of type %T", v) 12612 } 12613 if value == nil { 12614 return nil 12615 } 12616 12617 shape, ok := value.(map[string]interface{}) 12618 if !ok { 12619 return fmt.Errorf("unexpected JSON type %v", value) 12620 } 12621 12622 var sv *types.ImageInserter 12623 if *v == nil { 12624 sv = &types.ImageInserter{} 12625 } else { 12626 sv = *v 12627 } 12628 12629 for key, value := range shape { 12630 switch key { 12631 case "insertableImages": 12632 if err := awsRestjson1_deserializeDocument__listOfInsertableImage(&sv.InsertableImages, value); err != nil { 12633 return err 12634 } 12635 12636 default: 12637 _, _ = key, value 12638 12639 } 12640 } 12641 *v = sv 12642 return nil 12643} 12644 12645func awsRestjson1_deserializeDocumentImscDestinationSettings(v **types.ImscDestinationSettings, value interface{}) error { 12646 if v == nil { 12647 return fmt.Errorf("unexpected nil of type %T", v) 12648 } 12649 if value == nil { 12650 return nil 12651 } 12652 12653 shape, ok := value.(map[string]interface{}) 12654 if !ok { 12655 return fmt.Errorf("unexpected JSON type %v", value) 12656 } 12657 12658 var sv *types.ImscDestinationSettings 12659 if *v == nil { 12660 sv = &types.ImscDestinationSettings{} 12661 } else { 12662 sv = *v 12663 } 12664 12665 for key, value := range shape { 12666 switch key { 12667 case "stylePassthrough": 12668 if value != nil { 12669 jtv, ok := value.(string) 12670 if !ok { 12671 return fmt.Errorf("expected ImscStylePassthrough to be of type string, got %T instead", value) 12672 } 12673 sv.StylePassthrough = types.ImscStylePassthrough(jtv) 12674 } 12675 12676 default: 12677 _, _ = key, value 12678 12679 } 12680 } 12681 *v = sv 12682 return nil 12683} 12684 12685func awsRestjson1_deserializeDocumentInput(v **types.Input, value interface{}) error { 12686 if v == nil { 12687 return fmt.Errorf("unexpected nil of type %T", v) 12688 } 12689 if value == nil { 12690 return nil 12691 } 12692 12693 shape, ok := value.(map[string]interface{}) 12694 if !ok { 12695 return fmt.Errorf("unexpected JSON type %v", value) 12696 } 12697 12698 var sv *types.Input 12699 if *v == nil { 12700 sv = &types.Input{} 12701 } else { 12702 sv = *v 12703 } 12704 12705 for key, value := range shape { 12706 switch key { 12707 case "audioSelectorGroups": 12708 if err := awsRestjson1_deserializeDocument__mapOfAudioSelectorGroup(&sv.AudioSelectorGroups, value); err != nil { 12709 return err 12710 } 12711 12712 case "audioSelectors": 12713 if err := awsRestjson1_deserializeDocument__mapOfAudioSelector(&sv.AudioSelectors, value); err != nil { 12714 return err 12715 } 12716 12717 case "captionSelectors": 12718 if err := awsRestjson1_deserializeDocument__mapOfCaptionSelector(&sv.CaptionSelectors, value); err != nil { 12719 return err 12720 } 12721 12722 case "crop": 12723 if err := awsRestjson1_deserializeDocumentRectangle(&sv.Crop, value); err != nil { 12724 return err 12725 } 12726 12727 case "deblockFilter": 12728 if value != nil { 12729 jtv, ok := value.(string) 12730 if !ok { 12731 return fmt.Errorf("expected InputDeblockFilter to be of type string, got %T instead", value) 12732 } 12733 sv.DeblockFilter = types.InputDeblockFilter(jtv) 12734 } 12735 12736 case "decryptionSettings": 12737 if err := awsRestjson1_deserializeDocumentInputDecryptionSettings(&sv.DecryptionSettings, value); err != nil { 12738 return err 12739 } 12740 12741 case "denoiseFilter": 12742 if value != nil { 12743 jtv, ok := value.(string) 12744 if !ok { 12745 return fmt.Errorf("expected InputDenoiseFilter to be of type string, got %T instead", value) 12746 } 12747 sv.DenoiseFilter = types.InputDenoiseFilter(jtv) 12748 } 12749 12750 case "fileInput": 12751 if value != nil { 12752 jtv, ok := value.(string) 12753 if !ok { 12754 return fmt.Errorf("expected __stringPatternS3MM2PPMM2VVMMPPEEGGMMPP3AAVVIIMMPP4FFLLVVMMPPTTMMPPGGMM4VVTTRRPPFF4VVMM2TTSSTTSS264HH264MMKKVVMMKKAAMMOOVVMMTTSSMM2TTWWMMVVaAAASSFFVVOOBB3GGPP3GGPPPPMMXXFFDDIIVVXXXXVVIIDDRRAAWWDDVVGGXXFFMM1VV3GG2VVMMFFMM3UU8WWEEBBMMLLCCHHGGXXFFMMPPEEGG2MMXXFFMMPPEEGG2MMXXFFHHDDWWAAVVYY4MMXXMMLLOOGGGGaAAATTMMOOSSHttpsMM2VVMMPPEEGGMMPP3AAVVIIMMPP4FFLLVVMMPPTTMMPPGGMM4VVTTRRPPFF4VVMM2TTSSTTSS264HH264MMKKVVMMKKAAMMOOVVMMTTSSMM2TTWWMMVVaAAASSFFVVOOBB3GGPP3GGPPPPMMXXFFDDIIVVXXXXVVIIDDRRAAWWDDVVGGXXFFMM1VV3GG2VVMMFFMM3UU8WWEEBBMMLLCCHHGGXXFFMMPPEEGG2MMXXFFMMPPEEGG2MMXXFFHHDDWWAAVVYY4MMXXMMLLOOGGGGaAAATTMMOOSS to be of type string, got %T instead", value) 12755 } 12756 sv.FileInput = ptr.String(jtv) 12757 } 12758 12759 case "filterEnable": 12760 if value != nil { 12761 jtv, ok := value.(string) 12762 if !ok { 12763 return fmt.Errorf("expected InputFilterEnable to be of type string, got %T instead", value) 12764 } 12765 sv.FilterEnable = types.InputFilterEnable(jtv) 12766 } 12767 12768 case "filterStrength": 12769 if value != nil { 12770 jtv, ok := value.(json.Number) 12771 if !ok { 12772 return fmt.Errorf("expected __integerMinNegative5Max5 to be json.Number, got %T instead", value) 12773 } 12774 i64, err := jtv.Int64() 12775 if err != nil { 12776 return err 12777 } 12778 sv.FilterStrength = int32(i64) 12779 } 12780 12781 case "imageInserter": 12782 if err := awsRestjson1_deserializeDocumentImageInserter(&sv.ImageInserter, value); err != nil { 12783 return err 12784 } 12785 12786 case "inputClippings": 12787 if err := awsRestjson1_deserializeDocument__listOfInputClipping(&sv.InputClippings, value); err != nil { 12788 return err 12789 } 12790 12791 case "inputScanType": 12792 if value != nil { 12793 jtv, ok := value.(string) 12794 if !ok { 12795 return fmt.Errorf("expected InputScanType to be of type string, got %T instead", value) 12796 } 12797 sv.InputScanType = types.InputScanType(jtv) 12798 } 12799 12800 case "position": 12801 if err := awsRestjson1_deserializeDocumentRectangle(&sv.Position, value); err != nil { 12802 return err 12803 } 12804 12805 case "programNumber": 12806 if value != nil { 12807 jtv, ok := value.(json.Number) 12808 if !ok { 12809 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 12810 } 12811 i64, err := jtv.Int64() 12812 if err != nil { 12813 return err 12814 } 12815 sv.ProgramNumber = int32(i64) 12816 } 12817 12818 case "psiControl": 12819 if value != nil { 12820 jtv, ok := value.(string) 12821 if !ok { 12822 return fmt.Errorf("expected InputPsiControl to be of type string, got %T instead", value) 12823 } 12824 sv.PsiControl = types.InputPsiControl(jtv) 12825 } 12826 12827 case "supplementalImps": 12828 if err := awsRestjson1_deserializeDocument__listOf__stringPatternS3ASSETMAPXml(&sv.SupplementalImps, value); err != nil { 12829 return err 12830 } 12831 12832 case "timecodeSource": 12833 if value != nil { 12834 jtv, ok := value.(string) 12835 if !ok { 12836 return fmt.Errorf("expected InputTimecodeSource to be of type string, got %T instead", value) 12837 } 12838 sv.TimecodeSource = types.InputTimecodeSource(jtv) 12839 } 12840 12841 case "timecodeStart": 12842 if value != nil { 12843 jtv, ok := value.(string) 12844 if !ok { 12845 return fmt.Errorf("expected __stringMin11Max11Pattern01D20305D205D to be of type string, got %T instead", value) 12846 } 12847 sv.TimecodeStart = ptr.String(jtv) 12848 } 12849 12850 case "videoSelector": 12851 if err := awsRestjson1_deserializeDocumentVideoSelector(&sv.VideoSelector, value); err != nil { 12852 return err 12853 } 12854 12855 default: 12856 _, _ = key, value 12857 12858 } 12859 } 12860 *v = sv 12861 return nil 12862} 12863 12864func awsRestjson1_deserializeDocumentInputClipping(v **types.InputClipping, value interface{}) error { 12865 if v == nil { 12866 return fmt.Errorf("unexpected nil of type %T", v) 12867 } 12868 if value == nil { 12869 return nil 12870 } 12871 12872 shape, ok := value.(map[string]interface{}) 12873 if !ok { 12874 return fmt.Errorf("unexpected JSON type %v", value) 12875 } 12876 12877 var sv *types.InputClipping 12878 if *v == nil { 12879 sv = &types.InputClipping{} 12880 } else { 12881 sv = *v 12882 } 12883 12884 for key, value := range shape { 12885 switch key { 12886 case "endTimecode": 12887 if value != nil { 12888 jtv, ok := value.(string) 12889 if !ok { 12890 return fmt.Errorf("expected __stringPattern010920405090509092 to be of type string, got %T instead", value) 12891 } 12892 sv.EndTimecode = ptr.String(jtv) 12893 } 12894 12895 case "startTimecode": 12896 if value != nil { 12897 jtv, ok := value.(string) 12898 if !ok { 12899 return fmt.Errorf("expected __stringPattern010920405090509092 to be of type string, got %T instead", value) 12900 } 12901 sv.StartTimecode = ptr.String(jtv) 12902 } 12903 12904 default: 12905 _, _ = key, value 12906 12907 } 12908 } 12909 *v = sv 12910 return nil 12911} 12912 12913func awsRestjson1_deserializeDocumentInputDecryptionSettings(v **types.InputDecryptionSettings, value interface{}) error { 12914 if v == nil { 12915 return fmt.Errorf("unexpected nil of type %T", v) 12916 } 12917 if value == nil { 12918 return nil 12919 } 12920 12921 shape, ok := value.(map[string]interface{}) 12922 if !ok { 12923 return fmt.Errorf("unexpected JSON type %v", value) 12924 } 12925 12926 var sv *types.InputDecryptionSettings 12927 if *v == nil { 12928 sv = &types.InputDecryptionSettings{} 12929 } else { 12930 sv = *v 12931 } 12932 12933 for key, value := range shape { 12934 switch key { 12935 case "decryptionMode": 12936 if value != nil { 12937 jtv, ok := value.(string) 12938 if !ok { 12939 return fmt.Errorf("expected DecryptionMode to be of type string, got %T instead", value) 12940 } 12941 sv.DecryptionMode = types.DecryptionMode(jtv) 12942 } 12943 12944 case "encryptedDecryptionKey": 12945 if value != nil { 12946 jtv, ok := value.(string) 12947 if !ok { 12948 return fmt.Errorf("expected __stringMin24Max512PatternAZaZ0902 to be of type string, got %T instead", value) 12949 } 12950 sv.EncryptedDecryptionKey = ptr.String(jtv) 12951 } 12952 12953 case "initializationVector": 12954 if value != nil { 12955 jtv, ok := value.(string) 12956 if !ok { 12957 return fmt.Errorf("expected __stringMin16Max24PatternAZaZ0922AZaZ0916 to be of type string, got %T instead", value) 12958 } 12959 sv.InitializationVector = ptr.String(jtv) 12960 } 12961 12962 case "kmsKeyRegion": 12963 if value != nil { 12964 jtv, ok := value.(string) 12965 if !ok { 12966 return fmt.Errorf("expected __stringMin9Max19PatternAZ26EastWestCentralNorthSouthEastWest1912 to be of type string, got %T instead", value) 12967 } 12968 sv.KmsKeyRegion = ptr.String(jtv) 12969 } 12970 12971 default: 12972 _, _ = key, value 12973 12974 } 12975 } 12976 *v = sv 12977 return nil 12978} 12979 12980func awsRestjson1_deserializeDocumentInputTemplate(v **types.InputTemplate, value interface{}) error { 12981 if v == nil { 12982 return fmt.Errorf("unexpected nil of type %T", v) 12983 } 12984 if value == nil { 12985 return nil 12986 } 12987 12988 shape, ok := value.(map[string]interface{}) 12989 if !ok { 12990 return fmt.Errorf("unexpected JSON type %v", value) 12991 } 12992 12993 var sv *types.InputTemplate 12994 if *v == nil { 12995 sv = &types.InputTemplate{} 12996 } else { 12997 sv = *v 12998 } 12999 13000 for key, value := range shape { 13001 switch key { 13002 case "audioSelectorGroups": 13003 if err := awsRestjson1_deserializeDocument__mapOfAudioSelectorGroup(&sv.AudioSelectorGroups, value); err != nil { 13004 return err 13005 } 13006 13007 case "audioSelectors": 13008 if err := awsRestjson1_deserializeDocument__mapOfAudioSelector(&sv.AudioSelectors, value); err != nil { 13009 return err 13010 } 13011 13012 case "captionSelectors": 13013 if err := awsRestjson1_deserializeDocument__mapOfCaptionSelector(&sv.CaptionSelectors, value); err != nil { 13014 return err 13015 } 13016 13017 case "crop": 13018 if err := awsRestjson1_deserializeDocumentRectangle(&sv.Crop, value); err != nil { 13019 return err 13020 } 13021 13022 case "deblockFilter": 13023 if value != nil { 13024 jtv, ok := value.(string) 13025 if !ok { 13026 return fmt.Errorf("expected InputDeblockFilter to be of type string, got %T instead", value) 13027 } 13028 sv.DeblockFilter = types.InputDeblockFilter(jtv) 13029 } 13030 13031 case "denoiseFilter": 13032 if value != nil { 13033 jtv, ok := value.(string) 13034 if !ok { 13035 return fmt.Errorf("expected InputDenoiseFilter to be of type string, got %T instead", value) 13036 } 13037 sv.DenoiseFilter = types.InputDenoiseFilter(jtv) 13038 } 13039 13040 case "filterEnable": 13041 if value != nil { 13042 jtv, ok := value.(string) 13043 if !ok { 13044 return fmt.Errorf("expected InputFilterEnable to be of type string, got %T instead", value) 13045 } 13046 sv.FilterEnable = types.InputFilterEnable(jtv) 13047 } 13048 13049 case "filterStrength": 13050 if value != nil { 13051 jtv, ok := value.(json.Number) 13052 if !ok { 13053 return fmt.Errorf("expected __integerMinNegative5Max5 to be json.Number, got %T instead", value) 13054 } 13055 i64, err := jtv.Int64() 13056 if err != nil { 13057 return err 13058 } 13059 sv.FilterStrength = int32(i64) 13060 } 13061 13062 case "imageInserter": 13063 if err := awsRestjson1_deserializeDocumentImageInserter(&sv.ImageInserter, value); err != nil { 13064 return err 13065 } 13066 13067 case "inputClippings": 13068 if err := awsRestjson1_deserializeDocument__listOfInputClipping(&sv.InputClippings, value); err != nil { 13069 return err 13070 } 13071 13072 case "inputScanType": 13073 if value != nil { 13074 jtv, ok := value.(string) 13075 if !ok { 13076 return fmt.Errorf("expected InputScanType to be of type string, got %T instead", value) 13077 } 13078 sv.InputScanType = types.InputScanType(jtv) 13079 } 13080 13081 case "position": 13082 if err := awsRestjson1_deserializeDocumentRectangle(&sv.Position, value); err != nil { 13083 return err 13084 } 13085 13086 case "programNumber": 13087 if value != nil { 13088 jtv, ok := value.(json.Number) 13089 if !ok { 13090 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 13091 } 13092 i64, err := jtv.Int64() 13093 if err != nil { 13094 return err 13095 } 13096 sv.ProgramNumber = int32(i64) 13097 } 13098 13099 case "psiControl": 13100 if value != nil { 13101 jtv, ok := value.(string) 13102 if !ok { 13103 return fmt.Errorf("expected InputPsiControl to be of type string, got %T instead", value) 13104 } 13105 sv.PsiControl = types.InputPsiControl(jtv) 13106 } 13107 13108 case "timecodeSource": 13109 if value != nil { 13110 jtv, ok := value.(string) 13111 if !ok { 13112 return fmt.Errorf("expected InputTimecodeSource to be of type string, got %T instead", value) 13113 } 13114 sv.TimecodeSource = types.InputTimecodeSource(jtv) 13115 } 13116 13117 case "timecodeStart": 13118 if value != nil { 13119 jtv, ok := value.(string) 13120 if !ok { 13121 return fmt.Errorf("expected __stringMin11Max11Pattern01D20305D205D to be of type string, got %T instead", value) 13122 } 13123 sv.TimecodeStart = ptr.String(jtv) 13124 } 13125 13126 case "videoSelector": 13127 if err := awsRestjson1_deserializeDocumentVideoSelector(&sv.VideoSelector, value); err != nil { 13128 return err 13129 } 13130 13131 default: 13132 _, _ = key, value 13133 13134 } 13135 } 13136 *v = sv 13137 return nil 13138} 13139 13140func awsRestjson1_deserializeDocumentInsertableImage(v **types.InsertableImage, value interface{}) error { 13141 if v == nil { 13142 return fmt.Errorf("unexpected nil of type %T", v) 13143 } 13144 if value == nil { 13145 return nil 13146 } 13147 13148 shape, ok := value.(map[string]interface{}) 13149 if !ok { 13150 return fmt.Errorf("unexpected JSON type %v", value) 13151 } 13152 13153 var sv *types.InsertableImage 13154 if *v == nil { 13155 sv = &types.InsertableImage{} 13156 } else { 13157 sv = *v 13158 } 13159 13160 for key, value := range shape { 13161 switch key { 13162 case "duration": 13163 if value != nil { 13164 jtv, ok := value.(json.Number) 13165 if !ok { 13166 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 13167 } 13168 i64, err := jtv.Int64() 13169 if err != nil { 13170 return err 13171 } 13172 sv.Duration = int32(i64) 13173 } 13174 13175 case "fadeIn": 13176 if value != nil { 13177 jtv, ok := value.(json.Number) 13178 if !ok { 13179 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 13180 } 13181 i64, err := jtv.Int64() 13182 if err != nil { 13183 return err 13184 } 13185 sv.FadeIn = int32(i64) 13186 } 13187 13188 case "fadeOut": 13189 if value != nil { 13190 jtv, ok := value.(json.Number) 13191 if !ok { 13192 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 13193 } 13194 i64, err := jtv.Int64() 13195 if err != nil { 13196 return err 13197 } 13198 sv.FadeOut = int32(i64) 13199 } 13200 13201 case "height": 13202 if value != nil { 13203 jtv, ok := value.(json.Number) 13204 if !ok { 13205 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 13206 } 13207 i64, err := jtv.Int64() 13208 if err != nil { 13209 return err 13210 } 13211 sv.Height = int32(i64) 13212 } 13213 13214 case "imageInserterInput": 13215 if value != nil { 13216 jtv, ok := value.(string) 13217 if !ok { 13218 return fmt.Errorf("expected __stringMin14PatternS3BmpBMPPngPNGTgaTGAHttpsBmpBMPPngPNGTgaTGA to be of type string, got %T instead", value) 13219 } 13220 sv.ImageInserterInput = ptr.String(jtv) 13221 } 13222 13223 case "imageX": 13224 if value != nil { 13225 jtv, ok := value.(json.Number) 13226 if !ok { 13227 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 13228 } 13229 i64, err := jtv.Int64() 13230 if err != nil { 13231 return err 13232 } 13233 sv.ImageX = int32(i64) 13234 } 13235 13236 case "imageY": 13237 if value != nil { 13238 jtv, ok := value.(json.Number) 13239 if !ok { 13240 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 13241 } 13242 i64, err := jtv.Int64() 13243 if err != nil { 13244 return err 13245 } 13246 sv.ImageY = int32(i64) 13247 } 13248 13249 case "layer": 13250 if value != nil { 13251 jtv, ok := value.(json.Number) 13252 if !ok { 13253 return fmt.Errorf("expected __integerMin0Max99 to be json.Number, got %T instead", value) 13254 } 13255 i64, err := jtv.Int64() 13256 if err != nil { 13257 return err 13258 } 13259 sv.Layer = int32(i64) 13260 } 13261 13262 case "opacity": 13263 if value != nil { 13264 jtv, ok := value.(json.Number) 13265 if !ok { 13266 return fmt.Errorf("expected __integerMin0Max100 to be json.Number, got %T instead", value) 13267 } 13268 i64, err := jtv.Int64() 13269 if err != nil { 13270 return err 13271 } 13272 sv.Opacity = int32(i64) 13273 } 13274 13275 case "startTime": 13276 if value != nil { 13277 jtv, ok := value.(string) 13278 if !ok { 13279 return fmt.Errorf("expected __stringPattern01D20305D205D to be of type string, got %T instead", value) 13280 } 13281 sv.StartTime = ptr.String(jtv) 13282 } 13283 13284 case "width": 13285 if value != nil { 13286 jtv, ok := value.(json.Number) 13287 if !ok { 13288 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 13289 } 13290 i64, err := jtv.Int64() 13291 if err != nil { 13292 return err 13293 } 13294 sv.Width = int32(i64) 13295 } 13296 13297 default: 13298 _, _ = key, value 13299 13300 } 13301 } 13302 *v = sv 13303 return nil 13304} 13305 13306func awsRestjson1_deserializeDocumentInternalServerErrorException(v **types.InternalServerErrorException, value interface{}) error { 13307 if v == nil { 13308 return fmt.Errorf("unexpected nil of type %T", v) 13309 } 13310 if value == nil { 13311 return nil 13312 } 13313 13314 shape, ok := value.(map[string]interface{}) 13315 if !ok { 13316 return fmt.Errorf("unexpected JSON type %v", value) 13317 } 13318 13319 var sv *types.InternalServerErrorException 13320 if *v == nil { 13321 sv = &types.InternalServerErrorException{} 13322 } else { 13323 sv = *v 13324 } 13325 13326 for key, value := range shape { 13327 switch key { 13328 case "message": 13329 if value != nil { 13330 jtv, ok := value.(string) 13331 if !ok { 13332 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13333 } 13334 sv.Message = ptr.String(jtv) 13335 } 13336 13337 default: 13338 _, _ = key, value 13339 13340 } 13341 } 13342 *v = sv 13343 return nil 13344} 13345 13346func awsRestjson1_deserializeDocumentJob(v **types.Job, value interface{}) error { 13347 if v == nil { 13348 return fmt.Errorf("unexpected nil of type %T", v) 13349 } 13350 if value == nil { 13351 return nil 13352 } 13353 13354 shape, ok := value.(map[string]interface{}) 13355 if !ok { 13356 return fmt.Errorf("unexpected JSON type %v", value) 13357 } 13358 13359 var sv *types.Job 13360 if *v == nil { 13361 sv = &types.Job{} 13362 } else { 13363 sv = *v 13364 } 13365 13366 for key, value := range shape { 13367 switch key { 13368 case "accelerationSettings": 13369 if err := awsRestjson1_deserializeDocumentAccelerationSettings(&sv.AccelerationSettings, value); err != nil { 13370 return err 13371 } 13372 13373 case "accelerationStatus": 13374 if value != nil { 13375 jtv, ok := value.(string) 13376 if !ok { 13377 return fmt.Errorf("expected AccelerationStatus to be of type string, got %T instead", value) 13378 } 13379 sv.AccelerationStatus = types.AccelerationStatus(jtv) 13380 } 13381 13382 case "arn": 13383 if value != nil { 13384 jtv, ok := value.(string) 13385 if !ok { 13386 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13387 } 13388 sv.Arn = ptr.String(jtv) 13389 } 13390 13391 case "billingTagsSource": 13392 if value != nil { 13393 jtv, ok := value.(string) 13394 if !ok { 13395 return fmt.Errorf("expected BillingTagsSource to be of type string, got %T instead", value) 13396 } 13397 sv.BillingTagsSource = types.BillingTagsSource(jtv) 13398 } 13399 13400 case "createdAt": 13401 if value != nil { 13402 switch jtv := value.(type) { 13403 case json.Number: 13404 f64, err := jtv.Float64() 13405 if err != nil { 13406 return err 13407 } 13408 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13409 13410 default: 13411 return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value) 13412 13413 } 13414 } 13415 13416 case "currentPhase": 13417 if value != nil { 13418 jtv, ok := value.(string) 13419 if !ok { 13420 return fmt.Errorf("expected JobPhase to be of type string, got %T instead", value) 13421 } 13422 sv.CurrentPhase = types.JobPhase(jtv) 13423 } 13424 13425 case "errorCode": 13426 if value != nil { 13427 jtv, ok := value.(json.Number) 13428 if !ok { 13429 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 13430 } 13431 i64, err := jtv.Int64() 13432 if err != nil { 13433 return err 13434 } 13435 sv.ErrorCode = int32(i64) 13436 } 13437 13438 case "errorMessage": 13439 if value != nil { 13440 jtv, ok := value.(string) 13441 if !ok { 13442 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13443 } 13444 sv.ErrorMessage = ptr.String(jtv) 13445 } 13446 13447 case "hopDestinations": 13448 if err := awsRestjson1_deserializeDocument__listOfHopDestination(&sv.HopDestinations, value); err != nil { 13449 return err 13450 } 13451 13452 case "id": 13453 if value != nil { 13454 jtv, ok := value.(string) 13455 if !ok { 13456 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13457 } 13458 sv.Id = ptr.String(jtv) 13459 } 13460 13461 case "jobPercentComplete": 13462 if value != nil { 13463 jtv, ok := value.(json.Number) 13464 if !ok { 13465 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 13466 } 13467 i64, err := jtv.Int64() 13468 if err != nil { 13469 return err 13470 } 13471 sv.JobPercentComplete = int32(i64) 13472 } 13473 13474 case "jobTemplate": 13475 if value != nil { 13476 jtv, ok := value.(string) 13477 if !ok { 13478 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13479 } 13480 sv.JobTemplate = ptr.String(jtv) 13481 } 13482 13483 case "messages": 13484 if err := awsRestjson1_deserializeDocumentJobMessages(&sv.Messages, value); err != nil { 13485 return err 13486 } 13487 13488 case "outputGroupDetails": 13489 if err := awsRestjson1_deserializeDocument__listOfOutputGroupDetail(&sv.OutputGroupDetails, value); err != nil { 13490 return err 13491 } 13492 13493 case "priority": 13494 if value != nil { 13495 jtv, ok := value.(json.Number) 13496 if !ok { 13497 return fmt.Errorf("expected __integerMinNegative50Max50 to be json.Number, got %T instead", value) 13498 } 13499 i64, err := jtv.Int64() 13500 if err != nil { 13501 return err 13502 } 13503 sv.Priority = int32(i64) 13504 } 13505 13506 case "queue": 13507 if value != nil { 13508 jtv, ok := value.(string) 13509 if !ok { 13510 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13511 } 13512 sv.Queue = ptr.String(jtv) 13513 } 13514 13515 case "queueTransitions": 13516 if err := awsRestjson1_deserializeDocument__listOfQueueTransition(&sv.QueueTransitions, value); err != nil { 13517 return err 13518 } 13519 13520 case "retryCount": 13521 if value != nil { 13522 jtv, ok := value.(json.Number) 13523 if !ok { 13524 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 13525 } 13526 i64, err := jtv.Int64() 13527 if err != nil { 13528 return err 13529 } 13530 sv.RetryCount = int32(i64) 13531 } 13532 13533 case "role": 13534 if value != nil { 13535 jtv, ok := value.(string) 13536 if !ok { 13537 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13538 } 13539 sv.Role = ptr.String(jtv) 13540 } 13541 13542 case "settings": 13543 if err := awsRestjson1_deserializeDocumentJobSettings(&sv.Settings, value); err != nil { 13544 return err 13545 } 13546 13547 case "simulateReservedQueue": 13548 if value != nil { 13549 jtv, ok := value.(string) 13550 if !ok { 13551 return fmt.Errorf("expected SimulateReservedQueue to be of type string, got %T instead", value) 13552 } 13553 sv.SimulateReservedQueue = types.SimulateReservedQueue(jtv) 13554 } 13555 13556 case "status": 13557 if value != nil { 13558 jtv, ok := value.(string) 13559 if !ok { 13560 return fmt.Errorf("expected JobStatus to be of type string, got %T instead", value) 13561 } 13562 sv.Status = types.JobStatus(jtv) 13563 } 13564 13565 case "statusUpdateInterval": 13566 if value != nil { 13567 jtv, ok := value.(string) 13568 if !ok { 13569 return fmt.Errorf("expected StatusUpdateInterval to be of type string, got %T instead", value) 13570 } 13571 sv.StatusUpdateInterval = types.StatusUpdateInterval(jtv) 13572 } 13573 13574 case "timing": 13575 if err := awsRestjson1_deserializeDocumentTiming(&sv.Timing, value); err != nil { 13576 return err 13577 } 13578 13579 case "userMetadata": 13580 if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.UserMetadata, value); err != nil { 13581 return err 13582 } 13583 13584 default: 13585 _, _ = key, value 13586 13587 } 13588 } 13589 *v = sv 13590 return nil 13591} 13592 13593func awsRestjson1_deserializeDocumentJobMessages(v **types.JobMessages, value interface{}) error { 13594 if v == nil { 13595 return fmt.Errorf("unexpected nil of type %T", v) 13596 } 13597 if value == nil { 13598 return nil 13599 } 13600 13601 shape, ok := value.(map[string]interface{}) 13602 if !ok { 13603 return fmt.Errorf("unexpected JSON type %v", value) 13604 } 13605 13606 var sv *types.JobMessages 13607 if *v == nil { 13608 sv = &types.JobMessages{} 13609 } else { 13610 sv = *v 13611 } 13612 13613 for key, value := range shape { 13614 switch key { 13615 case "info": 13616 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.Info, value); err != nil { 13617 return err 13618 } 13619 13620 case "warning": 13621 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.Warning, value); err != nil { 13622 return err 13623 } 13624 13625 default: 13626 _, _ = key, value 13627 13628 } 13629 } 13630 *v = sv 13631 return nil 13632} 13633 13634func awsRestjson1_deserializeDocumentJobSettings(v **types.JobSettings, value interface{}) error { 13635 if v == nil { 13636 return fmt.Errorf("unexpected nil of type %T", v) 13637 } 13638 if value == nil { 13639 return nil 13640 } 13641 13642 shape, ok := value.(map[string]interface{}) 13643 if !ok { 13644 return fmt.Errorf("unexpected JSON type %v", value) 13645 } 13646 13647 var sv *types.JobSettings 13648 if *v == nil { 13649 sv = &types.JobSettings{} 13650 } else { 13651 sv = *v 13652 } 13653 13654 for key, value := range shape { 13655 switch key { 13656 case "adAvailOffset": 13657 if value != nil { 13658 jtv, ok := value.(json.Number) 13659 if !ok { 13660 return fmt.Errorf("expected __integerMinNegative1000Max1000 to be json.Number, got %T instead", value) 13661 } 13662 i64, err := jtv.Int64() 13663 if err != nil { 13664 return err 13665 } 13666 sv.AdAvailOffset = int32(i64) 13667 } 13668 13669 case "availBlanking": 13670 if err := awsRestjson1_deserializeDocumentAvailBlanking(&sv.AvailBlanking, value); err != nil { 13671 return err 13672 } 13673 13674 case "esam": 13675 if err := awsRestjson1_deserializeDocumentEsamSettings(&sv.Esam, value); err != nil { 13676 return err 13677 } 13678 13679 case "extendedDataServices": 13680 if err := awsRestjson1_deserializeDocumentExtendedDataServices(&sv.ExtendedDataServices, value); err != nil { 13681 return err 13682 } 13683 13684 case "inputs": 13685 if err := awsRestjson1_deserializeDocument__listOfInput(&sv.Inputs, value); err != nil { 13686 return err 13687 } 13688 13689 case "kantarWatermark": 13690 if err := awsRestjson1_deserializeDocumentKantarWatermarkSettings(&sv.KantarWatermark, value); err != nil { 13691 return err 13692 } 13693 13694 case "motionImageInserter": 13695 if err := awsRestjson1_deserializeDocumentMotionImageInserter(&sv.MotionImageInserter, value); err != nil { 13696 return err 13697 } 13698 13699 case "nielsenConfiguration": 13700 if err := awsRestjson1_deserializeDocumentNielsenConfiguration(&sv.NielsenConfiguration, value); err != nil { 13701 return err 13702 } 13703 13704 case "nielsenNonLinearWatermark": 13705 if err := awsRestjson1_deserializeDocumentNielsenNonLinearWatermarkSettings(&sv.NielsenNonLinearWatermark, value); err != nil { 13706 return err 13707 } 13708 13709 case "outputGroups": 13710 if err := awsRestjson1_deserializeDocument__listOfOutputGroup(&sv.OutputGroups, value); err != nil { 13711 return err 13712 } 13713 13714 case "timecodeConfig": 13715 if err := awsRestjson1_deserializeDocumentTimecodeConfig(&sv.TimecodeConfig, value); err != nil { 13716 return err 13717 } 13718 13719 case "timedMetadataInsertion": 13720 if err := awsRestjson1_deserializeDocumentTimedMetadataInsertion(&sv.TimedMetadataInsertion, value); err != nil { 13721 return err 13722 } 13723 13724 default: 13725 _, _ = key, value 13726 13727 } 13728 } 13729 *v = sv 13730 return nil 13731} 13732 13733func awsRestjson1_deserializeDocumentJobTemplate(v **types.JobTemplate, value interface{}) error { 13734 if v == nil { 13735 return fmt.Errorf("unexpected nil of type %T", v) 13736 } 13737 if value == nil { 13738 return nil 13739 } 13740 13741 shape, ok := value.(map[string]interface{}) 13742 if !ok { 13743 return fmt.Errorf("unexpected JSON type %v", value) 13744 } 13745 13746 var sv *types.JobTemplate 13747 if *v == nil { 13748 sv = &types.JobTemplate{} 13749 } else { 13750 sv = *v 13751 } 13752 13753 for key, value := range shape { 13754 switch key { 13755 case "accelerationSettings": 13756 if err := awsRestjson1_deserializeDocumentAccelerationSettings(&sv.AccelerationSettings, value); err != nil { 13757 return err 13758 } 13759 13760 case "arn": 13761 if value != nil { 13762 jtv, ok := value.(string) 13763 if !ok { 13764 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13765 } 13766 sv.Arn = ptr.String(jtv) 13767 } 13768 13769 case "category": 13770 if value != nil { 13771 jtv, ok := value.(string) 13772 if !ok { 13773 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13774 } 13775 sv.Category = ptr.String(jtv) 13776 } 13777 13778 case "createdAt": 13779 if value != nil { 13780 switch jtv := value.(type) { 13781 case json.Number: 13782 f64, err := jtv.Float64() 13783 if err != nil { 13784 return err 13785 } 13786 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13787 13788 default: 13789 return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value) 13790 13791 } 13792 } 13793 13794 case "description": 13795 if value != nil { 13796 jtv, ok := value.(string) 13797 if !ok { 13798 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13799 } 13800 sv.Description = ptr.String(jtv) 13801 } 13802 13803 case "hopDestinations": 13804 if err := awsRestjson1_deserializeDocument__listOfHopDestination(&sv.HopDestinations, value); err != nil { 13805 return err 13806 } 13807 13808 case "lastUpdated": 13809 if value != nil { 13810 switch jtv := value.(type) { 13811 case json.Number: 13812 f64, err := jtv.Float64() 13813 if err != nil { 13814 return err 13815 } 13816 sv.LastUpdated = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13817 13818 default: 13819 return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value) 13820 13821 } 13822 } 13823 13824 case "name": 13825 if value != nil { 13826 jtv, ok := value.(string) 13827 if !ok { 13828 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13829 } 13830 sv.Name = ptr.String(jtv) 13831 } 13832 13833 case "priority": 13834 if value != nil { 13835 jtv, ok := value.(json.Number) 13836 if !ok { 13837 return fmt.Errorf("expected __integerMinNegative50Max50 to be json.Number, got %T instead", value) 13838 } 13839 i64, err := jtv.Int64() 13840 if err != nil { 13841 return err 13842 } 13843 sv.Priority = int32(i64) 13844 } 13845 13846 case "queue": 13847 if value != nil { 13848 jtv, ok := value.(string) 13849 if !ok { 13850 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 13851 } 13852 sv.Queue = ptr.String(jtv) 13853 } 13854 13855 case "settings": 13856 if err := awsRestjson1_deserializeDocumentJobTemplateSettings(&sv.Settings, value); err != nil { 13857 return err 13858 } 13859 13860 case "statusUpdateInterval": 13861 if value != nil { 13862 jtv, ok := value.(string) 13863 if !ok { 13864 return fmt.Errorf("expected StatusUpdateInterval to be of type string, got %T instead", value) 13865 } 13866 sv.StatusUpdateInterval = types.StatusUpdateInterval(jtv) 13867 } 13868 13869 case "type": 13870 if value != nil { 13871 jtv, ok := value.(string) 13872 if !ok { 13873 return fmt.Errorf("expected Type to be of type string, got %T instead", value) 13874 } 13875 sv.Type = types.Type(jtv) 13876 } 13877 13878 default: 13879 _, _ = key, value 13880 13881 } 13882 } 13883 *v = sv 13884 return nil 13885} 13886 13887func awsRestjson1_deserializeDocumentJobTemplateSettings(v **types.JobTemplateSettings, value interface{}) error { 13888 if v == nil { 13889 return fmt.Errorf("unexpected nil of type %T", v) 13890 } 13891 if value == nil { 13892 return nil 13893 } 13894 13895 shape, ok := value.(map[string]interface{}) 13896 if !ok { 13897 return fmt.Errorf("unexpected JSON type %v", value) 13898 } 13899 13900 var sv *types.JobTemplateSettings 13901 if *v == nil { 13902 sv = &types.JobTemplateSettings{} 13903 } else { 13904 sv = *v 13905 } 13906 13907 for key, value := range shape { 13908 switch key { 13909 case "adAvailOffset": 13910 if value != nil { 13911 jtv, ok := value.(json.Number) 13912 if !ok { 13913 return fmt.Errorf("expected __integerMinNegative1000Max1000 to be json.Number, got %T instead", value) 13914 } 13915 i64, err := jtv.Int64() 13916 if err != nil { 13917 return err 13918 } 13919 sv.AdAvailOffset = int32(i64) 13920 } 13921 13922 case "availBlanking": 13923 if err := awsRestjson1_deserializeDocumentAvailBlanking(&sv.AvailBlanking, value); err != nil { 13924 return err 13925 } 13926 13927 case "esam": 13928 if err := awsRestjson1_deserializeDocumentEsamSettings(&sv.Esam, value); err != nil { 13929 return err 13930 } 13931 13932 case "extendedDataServices": 13933 if err := awsRestjson1_deserializeDocumentExtendedDataServices(&sv.ExtendedDataServices, value); err != nil { 13934 return err 13935 } 13936 13937 case "inputs": 13938 if err := awsRestjson1_deserializeDocument__listOfInputTemplate(&sv.Inputs, value); err != nil { 13939 return err 13940 } 13941 13942 case "kantarWatermark": 13943 if err := awsRestjson1_deserializeDocumentKantarWatermarkSettings(&sv.KantarWatermark, value); err != nil { 13944 return err 13945 } 13946 13947 case "motionImageInserter": 13948 if err := awsRestjson1_deserializeDocumentMotionImageInserter(&sv.MotionImageInserter, value); err != nil { 13949 return err 13950 } 13951 13952 case "nielsenConfiguration": 13953 if err := awsRestjson1_deserializeDocumentNielsenConfiguration(&sv.NielsenConfiguration, value); err != nil { 13954 return err 13955 } 13956 13957 case "nielsenNonLinearWatermark": 13958 if err := awsRestjson1_deserializeDocumentNielsenNonLinearWatermarkSettings(&sv.NielsenNonLinearWatermark, value); err != nil { 13959 return err 13960 } 13961 13962 case "outputGroups": 13963 if err := awsRestjson1_deserializeDocument__listOfOutputGroup(&sv.OutputGroups, value); err != nil { 13964 return err 13965 } 13966 13967 case "timecodeConfig": 13968 if err := awsRestjson1_deserializeDocumentTimecodeConfig(&sv.TimecodeConfig, value); err != nil { 13969 return err 13970 } 13971 13972 case "timedMetadataInsertion": 13973 if err := awsRestjson1_deserializeDocumentTimedMetadataInsertion(&sv.TimedMetadataInsertion, value); err != nil { 13974 return err 13975 } 13976 13977 default: 13978 _, _ = key, value 13979 13980 } 13981 } 13982 *v = sv 13983 return nil 13984} 13985 13986func awsRestjson1_deserializeDocumentKantarWatermarkSettings(v **types.KantarWatermarkSettings, value interface{}) error { 13987 if v == nil { 13988 return fmt.Errorf("unexpected nil of type %T", v) 13989 } 13990 if value == nil { 13991 return nil 13992 } 13993 13994 shape, ok := value.(map[string]interface{}) 13995 if !ok { 13996 return fmt.Errorf("unexpected JSON type %v", value) 13997 } 13998 13999 var sv *types.KantarWatermarkSettings 14000 if *v == nil { 14001 sv = &types.KantarWatermarkSettings{} 14002 } else { 14003 sv = *v 14004 } 14005 14006 for key, value := range shape { 14007 switch key { 14008 case "channelName": 14009 if value != nil { 14010 jtv, ok := value.(string) 14011 if !ok { 14012 return fmt.Errorf("expected __stringMin1Max20 to be of type string, got %T instead", value) 14013 } 14014 sv.ChannelName = ptr.String(jtv) 14015 } 14016 14017 case "contentReference": 14018 if value != nil { 14019 jtv, ok := value.(string) 14020 if !ok { 14021 return fmt.Errorf("expected __stringMin1Max50PatternAZAZ09 to be of type string, got %T instead", value) 14022 } 14023 sv.ContentReference = ptr.String(jtv) 14024 } 14025 14026 case "credentialsSecretName": 14027 if value != nil { 14028 jtv, ok := value.(string) 14029 if !ok { 14030 return fmt.Errorf("expected __stringMin1Max512PatternAZAZ09 to be of type string, got %T instead", value) 14031 } 14032 sv.CredentialsSecretName = ptr.String(jtv) 14033 } 14034 14035 case "fileOffset": 14036 if value != nil { 14037 switch jtv := value.(type) { 14038 case json.Number: 14039 f64, err := jtv.Float64() 14040 if err != nil { 14041 return err 14042 } 14043 sv.FileOffset = f64 14044 14045 case string: 14046 var f64 float64 14047 switch { 14048 case strings.EqualFold(jtv, "NaN"): 14049 f64 = math.NaN() 14050 14051 case strings.EqualFold(jtv, "Infinity"): 14052 f64 = math.Inf(1) 14053 14054 case strings.EqualFold(jtv, "-Infinity"): 14055 f64 = math.Inf(-1) 14056 14057 default: 14058 return fmt.Errorf("unknown JSON number value: %s", jtv) 14059 14060 } 14061 sv.FileOffset = f64 14062 14063 default: 14064 return fmt.Errorf("expected __doubleMin0 to be a JSON Number, got %T instead", value) 14065 14066 } 14067 } 14068 14069 case "kantarLicenseId": 14070 if value != nil { 14071 jtv, ok := value.(json.Number) 14072 if !ok { 14073 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 14074 } 14075 i64, err := jtv.Int64() 14076 if err != nil { 14077 return err 14078 } 14079 sv.KantarLicenseId = int32(i64) 14080 } 14081 14082 case "kantarServerUrl": 14083 if value != nil { 14084 jtv, ok := value.(string) 14085 if !ok { 14086 return fmt.Errorf("expected __stringPatternHttpsKantarmediaCom to be of type string, got %T instead", value) 14087 } 14088 sv.KantarServerUrl = ptr.String(jtv) 14089 } 14090 14091 case "logDestination": 14092 if value != nil { 14093 jtv, ok := value.(string) 14094 if !ok { 14095 return fmt.Errorf("expected __stringPatternS3 to be of type string, got %T instead", value) 14096 } 14097 sv.LogDestination = ptr.String(jtv) 14098 } 14099 14100 case "metadata3": 14101 if value != nil { 14102 jtv, ok := value.(string) 14103 if !ok { 14104 return fmt.Errorf("expected __stringMin1Max50 to be of type string, got %T instead", value) 14105 } 14106 sv.Metadata3 = ptr.String(jtv) 14107 } 14108 14109 case "metadata4": 14110 if value != nil { 14111 jtv, ok := value.(string) 14112 if !ok { 14113 return fmt.Errorf("expected __stringMin1Max50 to be of type string, got %T instead", value) 14114 } 14115 sv.Metadata4 = ptr.String(jtv) 14116 } 14117 14118 case "metadata5": 14119 if value != nil { 14120 jtv, ok := value.(string) 14121 if !ok { 14122 return fmt.Errorf("expected __stringMin1Max50 to be of type string, got %T instead", value) 14123 } 14124 sv.Metadata5 = ptr.String(jtv) 14125 } 14126 14127 case "metadata6": 14128 if value != nil { 14129 jtv, ok := value.(string) 14130 if !ok { 14131 return fmt.Errorf("expected __stringMin1Max50 to be of type string, got %T instead", value) 14132 } 14133 sv.Metadata6 = ptr.String(jtv) 14134 } 14135 14136 case "metadata7": 14137 if value != nil { 14138 jtv, ok := value.(string) 14139 if !ok { 14140 return fmt.Errorf("expected __stringMin1Max50 to be of type string, got %T instead", value) 14141 } 14142 sv.Metadata7 = ptr.String(jtv) 14143 } 14144 14145 case "metadata8": 14146 if value != nil { 14147 jtv, ok := value.(string) 14148 if !ok { 14149 return fmt.Errorf("expected __stringMin1Max50 to be of type string, got %T instead", value) 14150 } 14151 sv.Metadata8 = ptr.String(jtv) 14152 } 14153 14154 default: 14155 _, _ = key, value 14156 14157 } 14158 } 14159 *v = sv 14160 return nil 14161} 14162 14163func awsRestjson1_deserializeDocumentM2tsScte35Esam(v **types.M2tsScte35Esam, value interface{}) error { 14164 if v == nil { 14165 return fmt.Errorf("unexpected nil of type %T", v) 14166 } 14167 if value == nil { 14168 return nil 14169 } 14170 14171 shape, ok := value.(map[string]interface{}) 14172 if !ok { 14173 return fmt.Errorf("unexpected JSON type %v", value) 14174 } 14175 14176 var sv *types.M2tsScte35Esam 14177 if *v == nil { 14178 sv = &types.M2tsScte35Esam{} 14179 } else { 14180 sv = *v 14181 } 14182 14183 for key, value := range shape { 14184 switch key { 14185 case "scte35EsamPid": 14186 if value != nil { 14187 jtv, ok := value.(json.Number) 14188 if !ok { 14189 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 14190 } 14191 i64, err := jtv.Int64() 14192 if err != nil { 14193 return err 14194 } 14195 sv.Scte35EsamPid = int32(i64) 14196 } 14197 14198 default: 14199 _, _ = key, value 14200 14201 } 14202 } 14203 *v = sv 14204 return nil 14205} 14206 14207func awsRestjson1_deserializeDocumentM2tsSettings(v **types.M2tsSettings, value interface{}) error { 14208 if v == nil { 14209 return fmt.Errorf("unexpected nil of type %T", v) 14210 } 14211 if value == nil { 14212 return nil 14213 } 14214 14215 shape, ok := value.(map[string]interface{}) 14216 if !ok { 14217 return fmt.Errorf("unexpected JSON type %v", value) 14218 } 14219 14220 var sv *types.M2tsSettings 14221 if *v == nil { 14222 sv = &types.M2tsSettings{} 14223 } else { 14224 sv = *v 14225 } 14226 14227 for key, value := range shape { 14228 switch key { 14229 case "audioBufferModel": 14230 if value != nil { 14231 jtv, ok := value.(string) 14232 if !ok { 14233 return fmt.Errorf("expected M2tsAudioBufferModel to be of type string, got %T instead", value) 14234 } 14235 sv.AudioBufferModel = types.M2tsAudioBufferModel(jtv) 14236 } 14237 14238 case "audioDuration": 14239 if value != nil { 14240 jtv, ok := value.(string) 14241 if !ok { 14242 return fmt.Errorf("expected M2tsAudioDuration to be of type string, got %T instead", value) 14243 } 14244 sv.AudioDuration = types.M2tsAudioDuration(jtv) 14245 } 14246 14247 case "audioFramesPerPes": 14248 if value != nil { 14249 jtv, ok := value.(json.Number) 14250 if !ok { 14251 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 14252 } 14253 i64, err := jtv.Int64() 14254 if err != nil { 14255 return err 14256 } 14257 sv.AudioFramesPerPes = int32(i64) 14258 } 14259 14260 case "audioPids": 14261 if err := awsRestjson1_deserializeDocument__listOf__integerMin32Max8182(&sv.AudioPids, value); err != nil { 14262 return err 14263 } 14264 14265 case "bitrate": 14266 if value != nil { 14267 jtv, ok := value.(json.Number) 14268 if !ok { 14269 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 14270 } 14271 i64, err := jtv.Int64() 14272 if err != nil { 14273 return err 14274 } 14275 sv.Bitrate = int32(i64) 14276 } 14277 14278 case "bufferModel": 14279 if value != nil { 14280 jtv, ok := value.(string) 14281 if !ok { 14282 return fmt.Errorf("expected M2tsBufferModel to be of type string, got %T instead", value) 14283 } 14284 sv.BufferModel = types.M2tsBufferModel(jtv) 14285 } 14286 14287 case "dataPTSControl": 14288 if value != nil { 14289 jtv, ok := value.(string) 14290 if !ok { 14291 return fmt.Errorf("expected M2tsDataPtsControl to be of type string, got %T instead", value) 14292 } 14293 sv.DataPTSControl = types.M2tsDataPtsControl(jtv) 14294 } 14295 14296 case "dvbNitSettings": 14297 if err := awsRestjson1_deserializeDocumentDvbNitSettings(&sv.DvbNitSettings, value); err != nil { 14298 return err 14299 } 14300 14301 case "dvbSdtSettings": 14302 if err := awsRestjson1_deserializeDocumentDvbSdtSettings(&sv.DvbSdtSettings, value); err != nil { 14303 return err 14304 } 14305 14306 case "dvbSubPids": 14307 if err := awsRestjson1_deserializeDocument__listOf__integerMin32Max8182(&sv.DvbSubPids, value); err != nil { 14308 return err 14309 } 14310 14311 case "dvbTdtSettings": 14312 if err := awsRestjson1_deserializeDocumentDvbTdtSettings(&sv.DvbTdtSettings, value); err != nil { 14313 return err 14314 } 14315 14316 case "dvbTeletextPid": 14317 if value != nil { 14318 jtv, ok := value.(json.Number) 14319 if !ok { 14320 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 14321 } 14322 i64, err := jtv.Int64() 14323 if err != nil { 14324 return err 14325 } 14326 sv.DvbTeletextPid = int32(i64) 14327 } 14328 14329 case "ebpAudioInterval": 14330 if value != nil { 14331 jtv, ok := value.(string) 14332 if !ok { 14333 return fmt.Errorf("expected M2tsEbpAudioInterval to be of type string, got %T instead", value) 14334 } 14335 sv.EbpAudioInterval = types.M2tsEbpAudioInterval(jtv) 14336 } 14337 14338 case "ebpPlacement": 14339 if value != nil { 14340 jtv, ok := value.(string) 14341 if !ok { 14342 return fmt.Errorf("expected M2tsEbpPlacement to be of type string, got %T instead", value) 14343 } 14344 sv.EbpPlacement = types.M2tsEbpPlacement(jtv) 14345 } 14346 14347 case "esRateInPes": 14348 if value != nil { 14349 jtv, ok := value.(string) 14350 if !ok { 14351 return fmt.Errorf("expected M2tsEsRateInPes to be of type string, got %T instead", value) 14352 } 14353 sv.EsRateInPes = types.M2tsEsRateInPes(jtv) 14354 } 14355 14356 case "forceTsVideoEbpOrder": 14357 if value != nil { 14358 jtv, ok := value.(string) 14359 if !ok { 14360 return fmt.Errorf("expected M2tsForceTsVideoEbpOrder to be of type string, got %T instead", value) 14361 } 14362 sv.ForceTsVideoEbpOrder = types.M2tsForceTsVideoEbpOrder(jtv) 14363 } 14364 14365 case "fragmentTime": 14366 if value != nil { 14367 switch jtv := value.(type) { 14368 case json.Number: 14369 f64, err := jtv.Float64() 14370 if err != nil { 14371 return err 14372 } 14373 sv.FragmentTime = f64 14374 14375 case string: 14376 var f64 float64 14377 switch { 14378 case strings.EqualFold(jtv, "NaN"): 14379 f64 = math.NaN() 14380 14381 case strings.EqualFold(jtv, "Infinity"): 14382 f64 = math.Inf(1) 14383 14384 case strings.EqualFold(jtv, "-Infinity"): 14385 f64 = math.Inf(-1) 14386 14387 default: 14388 return fmt.Errorf("unknown JSON number value: %s", jtv) 14389 14390 } 14391 sv.FragmentTime = f64 14392 14393 default: 14394 return fmt.Errorf("expected __doubleMin0 to be a JSON Number, got %T instead", value) 14395 14396 } 14397 } 14398 14399 case "maxPcrInterval": 14400 if value != nil { 14401 jtv, ok := value.(json.Number) 14402 if !ok { 14403 return fmt.Errorf("expected __integerMin0Max500 to be json.Number, got %T instead", value) 14404 } 14405 i64, err := jtv.Int64() 14406 if err != nil { 14407 return err 14408 } 14409 sv.MaxPcrInterval = int32(i64) 14410 } 14411 14412 case "minEbpInterval": 14413 if value != nil { 14414 jtv, ok := value.(json.Number) 14415 if !ok { 14416 return fmt.Errorf("expected __integerMin0Max10000 to be json.Number, got %T instead", value) 14417 } 14418 i64, err := jtv.Int64() 14419 if err != nil { 14420 return err 14421 } 14422 sv.MinEbpInterval = int32(i64) 14423 } 14424 14425 case "nielsenId3": 14426 if value != nil { 14427 jtv, ok := value.(string) 14428 if !ok { 14429 return fmt.Errorf("expected M2tsNielsenId3 to be of type string, got %T instead", value) 14430 } 14431 sv.NielsenId3 = types.M2tsNielsenId3(jtv) 14432 } 14433 14434 case "nullPacketBitrate": 14435 if value != nil { 14436 switch jtv := value.(type) { 14437 case json.Number: 14438 f64, err := jtv.Float64() 14439 if err != nil { 14440 return err 14441 } 14442 sv.NullPacketBitrate = f64 14443 14444 case string: 14445 var f64 float64 14446 switch { 14447 case strings.EqualFold(jtv, "NaN"): 14448 f64 = math.NaN() 14449 14450 case strings.EqualFold(jtv, "Infinity"): 14451 f64 = math.Inf(1) 14452 14453 case strings.EqualFold(jtv, "-Infinity"): 14454 f64 = math.Inf(-1) 14455 14456 default: 14457 return fmt.Errorf("unknown JSON number value: %s", jtv) 14458 14459 } 14460 sv.NullPacketBitrate = f64 14461 14462 default: 14463 return fmt.Errorf("expected __doubleMin0 to be a JSON Number, got %T instead", value) 14464 14465 } 14466 } 14467 14468 case "patInterval": 14469 if value != nil { 14470 jtv, ok := value.(json.Number) 14471 if !ok { 14472 return fmt.Errorf("expected __integerMin0Max1000 to be json.Number, got %T instead", value) 14473 } 14474 i64, err := jtv.Int64() 14475 if err != nil { 14476 return err 14477 } 14478 sv.PatInterval = int32(i64) 14479 } 14480 14481 case "pcrControl": 14482 if value != nil { 14483 jtv, ok := value.(string) 14484 if !ok { 14485 return fmt.Errorf("expected M2tsPcrControl to be of type string, got %T instead", value) 14486 } 14487 sv.PcrControl = types.M2tsPcrControl(jtv) 14488 } 14489 14490 case "pcrPid": 14491 if value != nil { 14492 jtv, ok := value.(json.Number) 14493 if !ok { 14494 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 14495 } 14496 i64, err := jtv.Int64() 14497 if err != nil { 14498 return err 14499 } 14500 sv.PcrPid = int32(i64) 14501 } 14502 14503 case "pmtInterval": 14504 if value != nil { 14505 jtv, ok := value.(json.Number) 14506 if !ok { 14507 return fmt.Errorf("expected __integerMin0Max1000 to be json.Number, got %T instead", value) 14508 } 14509 i64, err := jtv.Int64() 14510 if err != nil { 14511 return err 14512 } 14513 sv.PmtInterval = int32(i64) 14514 } 14515 14516 case "pmtPid": 14517 if value != nil { 14518 jtv, ok := value.(json.Number) 14519 if !ok { 14520 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 14521 } 14522 i64, err := jtv.Int64() 14523 if err != nil { 14524 return err 14525 } 14526 sv.PmtPid = int32(i64) 14527 } 14528 14529 case "privateMetadataPid": 14530 if value != nil { 14531 jtv, ok := value.(json.Number) 14532 if !ok { 14533 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 14534 } 14535 i64, err := jtv.Int64() 14536 if err != nil { 14537 return err 14538 } 14539 sv.PrivateMetadataPid = int32(i64) 14540 } 14541 14542 case "programNumber": 14543 if value != nil { 14544 jtv, ok := value.(json.Number) 14545 if !ok { 14546 return fmt.Errorf("expected __integerMin0Max65535 to be json.Number, got %T instead", value) 14547 } 14548 i64, err := jtv.Int64() 14549 if err != nil { 14550 return err 14551 } 14552 sv.ProgramNumber = int32(i64) 14553 } 14554 14555 case "rateMode": 14556 if value != nil { 14557 jtv, ok := value.(string) 14558 if !ok { 14559 return fmt.Errorf("expected M2tsRateMode to be of type string, got %T instead", value) 14560 } 14561 sv.RateMode = types.M2tsRateMode(jtv) 14562 } 14563 14564 case "scte35Esam": 14565 if err := awsRestjson1_deserializeDocumentM2tsScte35Esam(&sv.Scte35Esam, value); err != nil { 14566 return err 14567 } 14568 14569 case "scte35Pid": 14570 if value != nil { 14571 jtv, ok := value.(json.Number) 14572 if !ok { 14573 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 14574 } 14575 i64, err := jtv.Int64() 14576 if err != nil { 14577 return err 14578 } 14579 sv.Scte35Pid = int32(i64) 14580 } 14581 14582 case "scte35Source": 14583 if value != nil { 14584 jtv, ok := value.(string) 14585 if !ok { 14586 return fmt.Errorf("expected M2tsScte35Source to be of type string, got %T instead", value) 14587 } 14588 sv.Scte35Source = types.M2tsScte35Source(jtv) 14589 } 14590 14591 case "segmentationMarkers": 14592 if value != nil { 14593 jtv, ok := value.(string) 14594 if !ok { 14595 return fmt.Errorf("expected M2tsSegmentationMarkers to be of type string, got %T instead", value) 14596 } 14597 sv.SegmentationMarkers = types.M2tsSegmentationMarkers(jtv) 14598 } 14599 14600 case "segmentationStyle": 14601 if value != nil { 14602 jtv, ok := value.(string) 14603 if !ok { 14604 return fmt.Errorf("expected M2tsSegmentationStyle to be of type string, got %T instead", value) 14605 } 14606 sv.SegmentationStyle = types.M2tsSegmentationStyle(jtv) 14607 } 14608 14609 case "segmentationTime": 14610 if value != nil { 14611 switch jtv := value.(type) { 14612 case json.Number: 14613 f64, err := jtv.Float64() 14614 if err != nil { 14615 return err 14616 } 14617 sv.SegmentationTime = f64 14618 14619 case string: 14620 var f64 float64 14621 switch { 14622 case strings.EqualFold(jtv, "NaN"): 14623 f64 = math.NaN() 14624 14625 case strings.EqualFold(jtv, "Infinity"): 14626 f64 = math.Inf(1) 14627 14628 case strings.EqualFold(jtv, "-Infinity"): 14629 f64 = math.Inf(-1) 14630 14631 default: 14632 return fmt.Errorf("unknown JSON number value: %s", jtv) 14633 14634 } 14635 sv.SegmentationTime = f64 14636 14637 default: 14638 return fmt.Errorf("expected __doubleMin0 to be a JSON Number, got %T instead", value) 14639 14640 } 14641 } 14642 14643 case "timedMetadataPid": 14644 if value != nil { 14645 jtv, ok := value.(json.Number) 14646 if !ok { 14647 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 14648 } 14649 i64, err := jtv.Int64() 14650 if err != nil { 14651 return err 14652 } 14653 sv.TimedMetadataPid = int32(i64) 14654 } 14655 14656 case "transportStreamId": 14657 if value != nil { 14658 jtv, ok := value.(json.Number) 14659 if !ok { 14660 return fmt.Errorf("expected __integerMin0Max65535 to be json.Number, got %T instead", value) 14661 } 14662 i64, err := jtv.Int64() 14663 if err != nil { 14664 return err 14665 } 14666 sv.TransportStreamId = int32(i64) 14667 } 14668 14669 case "videoPid": 14670 if value != nil { 14671 jtv, ok := value.(json.Number) 14672 if !ok { 14673 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 14674 } 14675 i64, err := jtv.Int64() 14676 if err != nil { 14677 return err 14678 } 14679 sv.VideoPid = int32(i64) 14680 } 14681 14682 default: 14683 _, _ = key, value 14684 14685 } 14686 } 14687 *v = sv 14688 return nil 14689} 14690 14691func awsRestjson1_deserializeDocumentM3u8Settings(v **types.M3u8Settings, value interface{}) error { 14692 if v == nil { 14693 return fmt.Errorf("unexpected nil of type %T", v) 14694 } 14695 if value == nil { 14696 return nil 14697 } 14698 14699 shape, ok := value.(map[string]interface{}) 14700 if !ok { 14701 return fmt.Errorf("unexpected JSON type %v", value) 14702 } 14703 14704 var sv *types.M3u8Settings 14705 if *v == nil { 14706 sv = &types.M3u8Settings{} 14707 } else { 14708 sv = *v 14709 } 14710 14711 for key, value := range shape { 14712 switch key { 14713 case "audioDuration": 14714 if value != nil { 14715 jtv, ok := value.(string) 14716 if !ok { 14717 return fmt.Errorf("expected M3u8AudioDuration to be of type string, got %T instead", value) 14718 } 14719 sv.AudioDuration = types.M3u8AudioDuration(jtv) 14720 } 14721 14722 case "audioFramesPerPes": 14723 if value != nil { 14724 jtv, ok := value.(json.Number) 14725 if !ok { 14726 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 14727 } 14728 i64, err := jtv.Int64() 14729 if err != nil { 14730 return err 14731 } 14732 sv.AudioFramesPerPes = int32(i64) 14733 } 14734 14735 case "audioPids": 14736 if err := awsRestjson1_deserializeDocument__listOf__integerMin32Max8182(&sv.AudioPids, value); err != nil { 14737 return err 14738 } 14739 14740 case "dataPTSControl": 14741 if value != nil { 14742 jtv, ok := value.(string) 14743 if !ok { 14744 return fmt.Errorf("expected M3u8DataPtsControl to be of type string, got %T instead", value) 14745 } 14746 sv.DataPTSControl = types.M3u8DataPtsControl(jtv) 14747 } 14748 14749 case "maxPcrInterval": 14750 if value != nil { 14751 jtv, ok := value.(json.Number) 14752 if !ok { 14753 return fmt.Errorf("expected __integerMin0Max500 to be json.Number, got %T instead", value) 14754 } 14755 i64, err := jtv.Int64() 14756 if err != nil { 14757 return err 14758 } 14759 sv.MaxPcrInterval = int32(i64) 14760 } 14761 14762 case "nielsenId3": 14763 if value != nil { 14764 jtv, ok := value.(string) 14765 if !ok { 14766 return fmt.Errorf("expected M3u8NielsenId3 to be of type string, got %T instead", value) 14767 } 14768 sv.NielsenId3 = types.M3u8NielsenId3(jtv) 14769 } 14770 14771 case "patInterval": 14772 if value != nil { 14773 jtv, ok := value.(json.Number) 14774 if !ok { 14775 return fmt.Errorf("expected __integerMin0Max1000 to be json.Number, got %T instead", value) 14776 } 14777 i64, err := jtv.Int64() 14778 if err != nil { 14779 return err 14780 } 14781 sv.PatInterval = int32(i64) 14782 } 14783 14784 case "pcrControl": 14785 if value != nil { 14786 jtv, ok := value.(string) 14787 if !ok { 14788 return fmt.Errorf("expected M3u8PcrControl to be of type string, got %T instead", value) 14789 } 14790 sv.PcrControl = types.M3u8PcrControl(jtv) 14791 } 14792 14793 case "pcrPid": 14794 if value != nil { 14795 jtv, ok := value.(json.Number) 14796 if !ok { 14797 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 14798 } 14799 i64, err := jtv.Int64() 14800 if err != nil { 14801 return err 14802 } 14803 sv.PcrPid = int32(i64) 14804 } 14805 14806 case "pmtInterval": 14807 if value != nil { 14808 jtv, ok := value.(json.Number) 14809 if !ok { 14810 return fmt.Errorf("expected __integerMin0Max1000 to be json.Number, got %T instead", value) 14811 } 14812 i64, err := jtv.Int64() 14813 if err != nil { 14814 return err 14815 } 14816 sv.PmtInterval = int32(i64) 14817 } 14818 14819 case "pmtPid": 14820 if value != nil { 14821 jtv, ok := value.(json.Number) 14822 if !ok { 14823 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 14824 } 14825 i64, err := jtv.Int64() 14826 if err != nil { 14827 return err 14828 } 14829 sv.PmtPid = int32(i64) 14830 } 14831 14832 case "privateMetadataPid": 14833 if value != nil { 14834 jtv, ok := value.(json.Number) 14835 if !ok { 14836 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 14837 } 14838 i64, err := jtv.Int64() 14839 if err != nil { 14840 return err 14841 } 14842 sv.PrivateMetadataPid = int32(i64) 14843 } 14844 14845 case "programNumber": 14846 if value != nil { 14847 jtv, ok := value.(json.Number) 14848 if !ok { 14849 return fmt.Errorf("expected __integerMin0Max65535 to be json.Number, got %T instead", value) 14850 } 14851 i64, err := jtv.Int64() 14852 if err != nil { 14853 return err 14854 } 14855 sv.ProgramNumber = int32(i64) 14856 } 14857 14858 case "scte35Pid": 14859 if value != nil { 14860 jtv, ok := value.(json.Number) 14861 if !ok { 14862 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 14863 } 14864 i64, err := jtv.Int64() 14865 if err != nil { 14866 return err 14867 } 14868 sv.Scte35Pid = int32(i64) 14869 } 14870 14871 case "scte35Source": 14872 if value != nil { 14873 jtv, ok := value.(string) 14874 if !ok { 14875 return fmt.Errorf("expected M3u8Scte35Source to be of type string, got %T instead", value) 14876 } 14877 sv.Scte35Source = types.M3u8Scte35Source(jtv) 14878 } 14879 14880 case "timedMetadata": 14881 if value != nil { 14882 jtv, ok := value.(string) 14883 if !ok { 14884 return fmt.Errorf("expected TimedMetadata to be of type string, got %T instead", value) 14885 } 14886 sv.TimedMetadata = types.TimedMetadata(jtv) 14887 } 14888 14889 case "timedMetadataPid": 14890 if value != nil { 14891 jtv, ok := value.(json.Number) 14892 if !ok { 14893 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 14894 } 14895 i64, err := jtv.Int64() 14896 if err != nil { 14897 return err 14898 } 14899 sv.TimedMetadataPid = int32(i64) 14900 } 14901 14902 case "transportStreamId": 14903 if value != nil { 14904 jtv, ok := value.(json.Number) 14905 if !ok { 14906 return fmt.Errorf("expected __integerMin0Max65535 to be json.Number, got %T instead", value) 14907 } 14908 i64, err := jtv.Int64() 14909 if err != nil { 14910 return err 14911 } 14912 sv.TransportStreamId = int32(i64) 14913 } 14914 14915 case "videoPid": 14916 if value != nil { 14917 jtv, ok := value.(json.Number) 14918 if !ok { 14919 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 14920 } 14921 i64, err := jtv.Int64() 14922 if err != nil { 14923 return err 14924 } 14925 sv.VideoPid = int32(i64) 14926 } 14927 14928 default: 14929 _, _ = key, value 14930 14931 } 14932 } 14933 *v = sv 14934 return nil 14935} 14936 14937func awsRestjson1_deserializeDocumentMotionImageInserter(v **types.MotionImageInserter, value interface{}) error { 14938 if v == nil { 14939 return fmt.Errorf("unexpected nil of type %T", v) 14940 } 14941 if value == nil { 14942 return nil 14943 } 14944 14945 shape, ok := value.(map[string]interface{}) 14946 if !ok { 14947 return fmt.Errorf("unexpected JSON type %v", value) 14948 } 14949 14950 var sv *types.MotionImageInserter 14951 if *v == nil { 14952 sv = &types.MotionImageInserter{} 14953 } else { 14954 sv = *v 14955 } 14956 14957 for key, value := range shape { 14958 switch key { 14959 case "framerate": 14960 if err := awsRestjson1_deserializeDocumentMotionImageInsertionFramerate(&sv.Framerate, value); err != nil { 14961 return err 14962 } 14963 14964 case "input": 14965 if value != nil { 14966 jtv, ok := value.(string) 14967 if !ok { 14968 return fmt.Errorf("expected __stringMin14PatternS3Mov09PngHttpsMov09Png to be of type string, got %T instead", value) 14969 } 14970 sv.Input = ptr.String(jtv) 14971 } 14972 14973 case "insertionMode": 14974 if value != nil { 14975 jtv, ok := value.(string) 14976 if !ok { 14977 return fmt.Errorf("expected MotionImageInsertionMode to be of type string, got %T instead", value) 14978 } 14979 sv.InsertionMode = types.MotionImageInsertionMode(jtv) 14980 } 14981 14982 case "offset": 14983 if err := awsRestjson1_deserializeDocumentMotionImageInsertionOffset(&sv.Offset, value); err != nil { 14984 return err 14985 } 14986 14987 case "playback": 14988 if value != nil { 14989 jtv, ok := value.(string) 14990 if !ok { 14991 return fmt.Errorf("expected MotionImagePlayback to be of type string, got %T instead", value) 14992 } 14993 sv.Playback = types.MotionImagePlayback(jtv) 14994 } 14995 14996 case "startTime": 14997 if value != nil { 14998 jtv, ok := value.(string) 14999 if !ok { 15000 return fmt.Errorf("expected __stringMin11Max11Pattern01D20305D205D to be of type string, got %T instead", value) 15001 } 15002 sv.StartTime = ptr.String(jtv) 15003 } 15004 15005 default: 15006 _, _ = key, value 15007 15008 } 15009 } 15010 *v = sv 15011 return nil 15012} 15013 15014func awsRestjson1_deserializeDocumentMotionImageInsertionFramerate(v **types.MotionImageInsertionFramerate, value interface{}) error { 15015 if v == nil { 15016 return fmt.Errorf("unexpected nil of type %T", v) 15017 } 15018 if value == nil { 15019 return nil 15020 } 15021 15022 shape, ok := value.(map[string]interface{}) 15023 if !ok { 15024 return fmt.Errorf("unexpected JSON type %v", value) 15025 } 15026 15027 var sv *types.MotionImageInsertionFramerate 15028 if *v == nil { 15029 sv = &types.MotionImageInsertionFramerate{} 15030 } else { 15031 sv = *v 15032 } 15033 15034 for key, value := range shape { 15035 switch key { 15036 case "framerateDenominator": 15037 if value != nil { 15038 jtv, ok := value.(json.Number) 15039 if !ok { 15040 return fmt.Errorf("expected __integerMin1Max17895697 to be json.Number, got %T instead", value) 15041 } 15042 i64, err := jtv.Int64() 15043 if err != nil { 15044 return err 15045 } 15046 sv.FramerateDenominator = int32(i64) 15047 } 15048 15049 case "framerateNumerator": 15050 if value != nil { 15051 jtv, ok := value.(json.Number) 15052 if !ok { 15053 return fmt.Errorf("expected __integerMin1Max2147483640 to be json.Number, got %T instead", value) 15054 } 15055 i64, err := jtv.Int64() 15056 if err != nil { 15057 return err 15058 } 15059 sv.FramerateNumerator = int32(i64) 15060 } 15061 15062 default: 15063 _, _ = key, value 15064 15065 } 15066 } 15067 *v = sv 15068 return nil 15069} 15070 15071func awsRestjson1_deserializeDocumentMotionImageInsertionOffset(v **types.MotionImageInsertionOffset, value interface{}) error { 15072 if v == nil { 15073 return fmt.Errorf("unexpected nil of type %T", v) 15074 } 15075 if value == nil { 15076 return nil 15077 } 15078 15079 shape, ok := value.(map[string]interface{}) 15080 if !ok { 15081 return fmt.Errorf("unexpected JSON type %v", value) 15082 } 15083 15084 var sv *types.MotionImageInsertionOffset 15085 if *v == nil { 15086 sv = &types.MotionImageInsertionOffset{} 15087 } else { 15088 sv = *v 15089 } 15090 15091 for key, value := range shape { 15092 switch key { 15093 case "imageX": 15094 if value != nil { 15095 jtv, ok := value.(json.Number) 15096 if !ok { 15097 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 15098 } 15099 i64, err := jtv.Int64() 15100 if err != nil { 15101 return err 15102 } 15103 sv.ImageX = int32(i64) 15104 } 15105 15106 case "imageY": 15107 if value != nil { 15108 jtv, ok := value.(json.Number) 15109 if !ok { 15110 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 15111 } 15112 i64, err := jtv.Int64() 15113 if err != nil { 15114 return err 15115 } 15116 sv.ImageY = int32(i64) 15117 } 15118 15119 default: 15120 _, _ = key, value 15121 15122 } 15123 } 15124 *v = sv 15125 return nil 15126} 15127 15128func awsRestjson1_deserializeDocumentMovSettings(v **types.MovSettings, value interface{}) error { 15129 if v == nil { 15130 return fmt.Errorf("unexpected nil of type %T", v) 15131 } 15132 if value == nil { 15133 return nil 15134 } 15135 15136 shape, ok := value.(map[string]interface{}) 15137 if !ok { 15138 return fmt.Errorf("unexpected JSON type %v", value) 15139 } 15140 15141 var sv *types.MovSettings 15142 if *v == nil { 15143 sv = &types.MovSettings{} 15144 } else { 15145 sv = *v 15146 } 15147 15148 for key, value := range shape { 15149 switch key { 15150 case "clapAtom": 15151 if value != nil { 15152 jtv, ok := value.(string) 15153 if !ok { 15154 return fmt.Errorf("expected MovClapAtom to be of type string, got %T instead", value) 15155 } 15156 sv.ClapAtom = types.MovClapAtom(jtv) 15157 } 15158 15159 case "cslgAtom": 15160 if value != nil { 15161 jtv, ok := value.(string) 15162 if !ok { 15163 return fmt.Errorf("expected MovCslgAtom to be of type string, got %T instead", value) 15164 } 15165 sv.CslgAtom = types.MovCslgAtom(jtv) 15166 } 15167 15168 case "mpeg2FourCCControl": 15169 if value != nil { 15170 jtv, ok := value.(string) 15171 if !ok { 15172 return fmt.Errorf("expected MovMpeg2FourCCControl to be of type string, got %T instead", value) 15173 } 15174 sv.Mpeg2FourCCControl = types.MovMpeg2FourCCControl(jtv) 15175 } 15176 15177 case "paddingControl": 15178 if value != nil { 15179 jtv, ok := value.(string) 15180 if !ok { 15181 return fmt.Errorf("expected MovPaddingControl to be of type string, got %T instead", value) 15182 } 15183 sv.PaddingControl = types.MovPaddingControl(jtv) 15184 } 15185 15186 case "reference": 15187 if value != nil { 15188 jtv, ok := value.(string) 15189 if !ok { 15190 return fmt.Errorf("expected MovReference to be of type string, got %T instead", value) 15191 } 15192 sv.Reference = types.MovReference(jtv) 15193 } 15194 15195 default: 15196 _, _ = key, value 15197 15198 } 15199 } 15200 *v = sv 15201 return nil 15202} 15203 15204func awsRestjson1_deserializeDocumentMp2Settings(v **types.Mp2Settings, value interface{}) error { 15205 if v == nil { 15206 return fmt.Errorf("unexpected nil of type %T", v) 15207 } 15208 if value == nil { 15209 return nil 15210 } 15211 15212 shape, ok := value.(map[string]interface{}) 15213 if !ok { 15214 return fmt.Errorf("unexpected JSON type %v", value) 15215 } 15216 15217 var sv *types.Mp2Settings 15218 if *v == nil { 15219 sv = &types.Mp2Settings{} 15220 } else { 15221 sv = *v 15222 } 15223 15224 for key, value := range shape { 15225 switch key { 15226 case "bitrate": 15227 if value != nil { 15228 jtv, ok := value.(json.Number) 15229 if !ok { 15230 return fmt.Errorf("expected __integerMin32000Max384000 to be json.Number, got %T instead", value) 15231 } 15232 i64, err := jtv.Int64() 15233 if err != nil { 15234 return err 15235 } 15236 sv.Bitrate = int32(i64) 15237 } 15238 15239 case "channels": 15240 if value != nil { 15241 jtv, ok := value.(json.Number) 15242 if !ok { 15243 return fmt.Errorf("expected __integerMin1Max2 to be json.Number, got %T instead", value) 15244 } 15245 i64, err := jtv.Int64() 15246 if err != nil { 15247 return err 15248 } 15249 sv.Channels = int32(i64) 15250 } 15251 15252 case "sampleRate": 15253 if value != nil { 15254 jtv, ok := value.(json.Number) 15255 if !ok { 15256 return fmt.Errorf("expected __integerMin32000Max48000 to be json.Number, got %T instead", value) 15257 } 15258 i64, err := jtv.Int64() 15259 if err != nil { 15260 return err 15261 } 15262 sv.SampleRate = int32(i64) 15263 } 15264 15265 default: 15266 _, _ = key, value 15267 15268 } 15269 } 15270 *v = sv 15271 return nil 15272} 15273 15274func awsRestjson1_deserializeDocumentMp3Settings(v **types.Mp3Settings, value interface{}) error { 15275 if v == nil { 15276 return fmt.Errorf("unexpected nil of type %T", v) 15277 } 15278 if value == nil { 15279 return nil 15280 } 15281 15282 shape, ok := value.(map[string]interface{}) 15283 if !ok { 15284 return fmt.Errorf("unexpected JSON type %v", value) 15285 } 15286 15287 var sv *types.Mp3Settings 15288 if *v == nil { 15289 sv = &types.Mp3Settings{} 15290 } else { 15291 sv = *v 15292 } 15293 15294 for key, value := range shape { 15295 switch key { 15296 case "bitrate": 15297 if value != nil { 15298 jtv, ok := value.(json.Number) 15299 if !ok { 15300 return fmt.Errorf("expected __integerMin16000Max320000 to be json.Number, got %T instead", value) 15301 } 15302 i64, err := jtv.Int64() 15303 if err != nil { 15304 return err 15305 } 15306 sv.Bitrate = int32(i64) 15307 } 15308 15309 case "channels": 15310 if value != nil { 15311 jtv, ok := value.(json.Number) 15312 if !ok { 15313 return fmt.Errorf("expected __integerMin1Max2 to be json.Number, got %T instead", value) 15314 } 15315 i64, err := jtv.Int64() 15316 if err != nil { 15317 return err 15318 } 15319 sv.Channels = int32(i64) 15320 } 15321 15322 case "rateControlMode": 15323 if value != nil { 15324 jtv, ok := value.(string) 15325 if !ok { 15326 return fmt.Errorf("expected Mp3RateControlMode to be of type string, got %T instead", value) 15327 } 15328 sv.RateControlMode = types.Mp3RateControlMode(jtv) 15329 } 15330 15331 case "sampleRate": 15332 if value != nil { 15333 jtv, ok := value.(json.Number) 15334 if !ok { 15335 return fmt.Errorf("expected __integerMin22050Max48000 to be json.Number, got %T instead", value) 15336 } 15337 i64, err := jtv.Int64() 15338 if err != nil { 15339 return err 15340 } 15341 sv.SampleRate = int32(i64) 15342 } 15343 15344 case "vbrQuality": 15345 if value != nil { 15346 jtv, ok := value.(json.Number) 15347 if !ok { 15348 return fmt.Errorf("expected __integerMin0Max9 to be json.Number, got %T instead", value) 15349 } 15350 i64, err := jtv.Int64() 15351 if err != nil { 15352 return err 15353 } 15354 sv.VbrQuality = int32(i64) 15355 } 15356 15357 default: 15358 _, _ = key, value 15359 15360 } 15361 } 15362 *v = sv 15363 return nil 15364} 15365 15366func awsRestjson1_deserializeDocumentMp4Settings(v **types.Mp4Settings, value interface{}) error { 15367 if v == nil { 15368 return fmt.Errorf("unexpected nil of type %T", v) 15369 } 15370 if value == nil { 15371 return nil 15372 } 15373 15374 shape, ok := value.(map[string]interface{}) 15375 if !ok { 15376 return fmt.Errorf("unexpected JSON type %v", value) 15377 } 15378 15379 var sv *types.Mp4Settings 15380 if *v == nil { 15381 sv = &types.Mp4Settings{} 15382 } else { 15383 sv = *v 15384 } 15385 15386 for key, value := range shape { 15387 switch key { 15388 case "audioDuration": 15389 if value != nil { 15390 jtv, ok := value.(string) 15391 if !ok { 15392 return fmt.Errorf("expected CmfcAudioDuration to be of type string, got %T instead", value) 15393 } 15394 sv.AudioDuration = types.CmfcAudioDuration(jtv) 15395 } 15396 15397 case "cslgAtom": 15398 if value != nil { 15399 jtv, ok := value.(string) 15400 if !ok { 15401 return fmt.Errorf("expected Mp4CslgAtom to be of type string, got %T instead", value) 15402 } 15403 sv.CslgAtom = types.Mp4CslgAtom(jtv) 15404 } 15405 15406 case "cttsVersion": 15407 if value != nil { 15408 jtv, ok := value.(json.Number) 15409 if !ok { 15410 return fmt.Errorf("expected __integerMin0Max1 to be json.Number, got %T instead", value) 15411 } 15412 i64, err := jtv.Int64() 15413 if err != nil { 15414 return err 15415 } 15416 sv.CttsVersion = int32(i64) 15417 } 15418 15419 case "freeSpaceBox": 15420 if value != nil { 15421 jtv, ok := value.(string) 15422 if !ok { 15423 return fmt.Errorf("expected Mp4FreeSpaceBox to be of type string, got %T instead", value) 15424 } 15425 sv.FreeSpaceBox = types.Mp4FreeSpaceBox(jtv) 15426 } 15427 15428 case "moovPlacement": 15429 if value != nil { 15430 jtv, ok := value.(string) 15431 if !ok { 15432 return fmt.Errorf("expected Mp4MoovPlacement to be of type string, got %T instead", value) 15433 } 15434 sv.MoovPlacement = types.Mp4MoovPlacement(jtv) 15435 } 15436 15437 case "mp4MajorBrand": 15438 if value != nil { 15439 jtv, ok := value.(string) 15440 if !ok { 15441 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15442 } 15443 sv.Mp4MajorBrand = ptr.String(jtv) 15444 } 15445 15446 default: 15447 _, _ = key, value 15448 15449 } 15450 } 15451 *v = sv 15452 return nil 15453} 15454 15455func awsRestjson1_deserializeDocumentMpdSettings(v **types.MpdSettings, value interface{}) error { 15456 if v == nil { 15457 return fmt.Errorf("unexpected nil of type %T", v) 15458 } 15459 if value == nil { 15460 return nil 15461 } 15462 15463 shape, ok := value.(map[string]interface{}) 15464 if !ok { 15465 return fmt.Errorf("unexpected JSON type %v", value) 15466 } 15467 15468 var sv *types.MpdSettings 15469 if *v == nil { 15470 sv = &types.MpdSettings{} 15471 } else { 15472 sv = *v 15473 } 15474 15475 for key, value := range shape { 15476 switch key { 15477 case "accessibilityCaptionHints": 15478 if value != nil { 15479 jtv, ok := value.(string) 15480 if !ok { 15481 return fmt.Errorf("expected MpdAccessibilityCaptionHints to be of type string, got %T instead", value) 15482 } 15483 sv.AccessibilityCaptionHints = types.MpdAccessibilityCaptionHints(jtv) 15484 } 15485 15486 case "audioDuration": 15487 if value != nil { 15488 jtv, ok := value.(string) 15489 if !ok { 15490 return fmt.Errorf("expected MpdAudioDuration to be of type string, got %T instead", value) 15491 } 15492 sv.AudioDuration = types.MpdAudioDuration(jtv) 15493 } 15494 15495 case "captionContainerType": 15496 if value != nil { 15497 jtv, ok := value.(string) 15498 if !ok { 15499 return fmt.Errorf("expected MpdCaptionContainerType to be of type string, got %T instead", value) 15500 } 15501 sv.CaptionContainerType = types.MpdCaptionContainerType(jtv) 15502 } 15503 15504 case "scte35Esam": 15505 if value != nil { 15506 jtv, ok := value.(string) 15507 if !ok { 15508 return fmt.Errorf("expected MpdScte35Esam to be of type string, got %T instead", value) 15509 } 15510 sv.Scte35Esam = types.MpdScte35Esam(jtv) 15511 } 15512 15513 case "scte35Source": 15514 if value != nil { 15515 jtv, ok := value.(string) 15516 if !ok { 15517 return fmt.Errorf("expected MpdScte35Source to be of type string, got %T instead", value) 15518 } 15519 sv.Scte35Source = types.MpdScte35Source(jtv) 15520 } 15521 15522 default: 15523 _, _ = key, value 15524 15525 } 15526 } 15527 *v = sv 15528 return nil 15529} 15530 15531func awsRestjson1_deserializeDocumentMpeg2Settings(v **types.Mpeg2Settings, value interface{}) error { 15532 if v == nil { 15533 return fmt.Errorf("unexpected nil of type %T", v) 15534 } 15535 if value == nil { 15536 return nil 15537 } 15538 15539 shape, ok := value.(map[string]interface{}) 15540 if !ok { 15541 return fmt.Errorf("unexpected JSON type %v", value) 15542 } 15543 15544 var sv *types.Mpeg2Settings 15545 if *v == nil { 15546 sv = &types.Mpeg2Settings{} 15547 } else { 15548 sv = *v 15549 } 15550 15551 for key, value := range shape { 15552 switch key { 15553 case "adaptiveQuantization": 15554 if value != nil { 15555 jtv, ok := value.(string) 15556 if !ok { 15557 return fmt.Errorf("expected Mpeg2AdaptiveQuantization to be of type string, got %T instead", value) 15558 } 15559 sv.AdaptiveQuantization = types.Mpeg2AdaptiveQuantization(jtv) 15560 } 15561 15562 case "bitrate": 15563 if value != nil { 15564 jtv, ok := value.(json.Number) 15565 if !ok { 15566 return fmt.Errorf("expected __integerMin1000Max288000000 to be json.Number, got %T instead", value) 15567 } 15568 i64, err := jtv.Int64() 15569 if err != nil { 15570 return err 15571 } 15572 sv.Bitrate = int32(i64) 15573 } 15574 15575 case "codecLevel": 15576 if value != nil { 15577 jtv, ok := value.(string) 15578 if !ok { 15579 return fmt.Errorf("expected Mpeg2CodecLevel to be of type string, got %T instead", value) 15580 } 15581 sv.CodecLevel = types.Mpeg2CodecLevel(jtv) 15582 } 15583 15584 case "codecProfile": 15585 if value != nil { 15586 jtv, ok := value.(string) 15587 if !ok { 15588 return fmt.Errorf("expected Mpeg2CodecProfile to be of type string, got %T instead", value) 15589 } 15590 sv.CodecProfile = types.Mpeg2CodecProfile(jtv) 15591 } 15592 15593 case "dynamicSubGop": 15594 if value != nil { 15595 jtv, ok := value.(string) 15596 if !ok { 15597 return fmt.Errorf("expected Mpeg2DynamicSubGop to be of type string, got %T instead", value) 15598 } 15599 sv.DynamicSubGop = types.Mpeg2DynamicSubGop(jtv) 15600 } 15601 15602 case "framerateControl": 15603 if value != nil { 15604 jtv, ok := value.(string) 15605 if !ok { 15606 return fmt.Errorf("expected Mpeg2FramerateControl to be of type string, got %T instead", value) 15607 } 15608 sv.FramerateControl = types.Mpeg2FramerateControl(jtv) 15609 } 15610 15611 case "framerateConversionAlgorithm": 15612 if value != nil { 15613 jtv, ok := value.(string) 15614 if !ok { 15615 return fmt.Errorf("expected Mpeg2FramerateConversionAlgorithm to be of type string, got %T instead", value) 15616 } 15617 sv.FramerateConversionAlgorithm = types.Mpeg2FramerateConversionAlgorithm(jtv) 15618 } 15619 15620 case "framerateDenominator": 15621 if value != nil { 15622 jtv, ok := value.(json.Number) 15623 if !ok { 15624 return fmt.Errorf("expected __integerMin1Max1001 to be json.Number, got %T instead", value) 15625 } 15626 i64, err := jtv.Int64() 15627 if err != nil { 15628 return err 15629 } 15630 sv.FramerateDenominator = int32(i64) 15631 } 15632 15633 case "framerateNumerator": 15634 if value != nil { 15635 jtv, ok := value.(json.Number) 15636 if !ok { 15637 return fmt.Errorf("expected __integerMin24Max60000 to be json.Number, got %T instead", value) 15638 } 15639 i64, err := jtv.Int64() 15640 if err != nil { 15641 return err 15642 } 15643 sv.FramerateNumerator = int32(i64) 15644 } 15645 15646 case "gopClosedCadence": 15647 if value != nil { 15648 jtv, ok := value.(json.Number) 15649 if !ok { 15650 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 15651 } 15652 i64, err := jtv.Int64() 15653 if err != nil { 15654 return err 15655 } 15656 sv.GopClosedCadence = int32(i64) 15657 } 15658 15659 case "gopSize": 15660 if value != nil { 15661 switch jtv := value.(type) { 15662 case json.Number: 15663 f64, err := jtv.Float64() 15664 if err != nil { 15665 return err 15666 } 15667 sv.GopSize = f64 15668 15669 case string: 15670 var f64 float64 15671 switch { 15672 case strings.EqualFold(jtv, "NaN"): 15673 f64 = math.NaN() 15674 15675 case strings.EqualFold(jtv, "Infinity"): 15676 f64 = math.Inf(1) 15677 15678 case strings.EqualFold(jtv, "-Infinity"): 15679 f64 = math.Inf(-1) 15680 15681 default: 15682 return fmt.Errorf("unknown JSON number value: %s", jtv) 15683 15684 } 15685 sv.GopSize = f64 15686 15687 default: 15688 return fmt.Errorf("expected __doubleMin0 to be a JSON Number, got %T instead", value) 15689 15690 } 15691 } 15692 15693 case "gopSizeUnits": 15694 if value != nil { 15695 jtv, ok := value.(string) 15696 if !ok { 15697 return fmt.Errorf("expected Mpeg2GopSizeUnits to be of type string, got %T instead", value) 15698 } 15699 sv.GopSizeUnits = types.Mpeg2GopSizeUnits(jtv) 15700 } 15701 15702 case "hrdBufferInitialFillPercentage": 15703 if value != nil { 15704 jtv, ok := value.(json.Number) 15705 if !ok { 15706 return fmt.Errorf("expected __integerMin0Max100 to be json.Number, got %T instead", value) 15707 } 15708 i64, err := jtv.Int64() 15709 if err != nil { 15710 return err 15711 } 15712 sv.HrdBufferInitialFillPercentage = int32(i64) 15713 } 15714 15715 case "hrdBufferSize": 15716 if value != nil { 15717 jtv, ok := value.(json.Number) 15718 if !ok { 15719 return fmt.Errorf("expected __integerMin0Max47185920 to be json.Number, got %T instead", value) 15720 } 15721 i64, err := jtv.Int64() 15722 if err != nil { 15723 return err 15724 } 15725 sv.HrdBufferSize = int32(i64) 15726 } 15727 15728 case "interlaceMode": 15729 if value != nil { 15730 jtv, ok := value.(string) 15731 if !ok { 15732 return fmt.Errorf("expected Mpeg2InterlaceMode to be of type string, got %T instead", value) 15733 } 15734 sv.InterlaceMode = types.Mpeg2InterlaceMode(jtv) 15735 } 15736 15737 case "intraDcPrecision": 15738 if value != nil { 15739 jtv, ok := value.(string) 15740 if !ok { 15741 return fmt.Errorf("expected Mpeg2IntraDcPrecision to be of type string, got %T instead", value) 15742 } 15743 sv.IntraDcPrecision = types.Mpeg2IntraDcPrecision(jtv) 15744 } 15745 15746 case "maxBitrate": 15747 if value != nil { 15748 jtv, ok := value.(json.Number) 15749 if !ok { 15750 return fmt.Errorf("expected __integerMin1000Max300000000 to be json.Number, got %T instead", value) 15751 } 15752 i64, err := jtv.Int64() 15753 if err != nil { 15754 return err 15755 } 15756 sv.MaxBitrate = int32(i64) 15757 } 15758 15759 case "minIInterval": 15760 if value != nil { 15761 jtv, ok := value.(json.Number) 15762 if !ok { 15763 return fmt.Errorf("expected __integerMin0Max30 to be json.Number, got %T instead", value) 15764 } 15765 i64, err := jtv.Int64() 15766 if err != nil { 15767 return err 15768 } 15769 sv.MinIInterval = int32(i64) 15770 } 15771 15772 case "numberBFramesBetweenReferenceFrames": 15773 if value != nil { 15774 jtv, ok := value.(json.Number) 15775 if !ok { 15776 return fmt.Errorf("expected __integerMin0Max7 to be json.Number, got %T instead", value) 15777 } 15778 i64, err := jtv.Int64() 15779 if err != nil { 15780 return err 15781 } 15782 sv.NumberBFramesBetweenReferenceFrames = int32(i64) 15783 } 15784 15785 case "parControl": 15786 if value != nil { 15787 jtv, ok := value.(string) 15788 if !ok { 15789 return fmt.Errorf("expected Mpeg2ParControl to be of type string, got %T instead", value) 15790 } 15791 sv.ParControl = types.Mpeg2ParControl(jtv) 15792 } 15793 15794 case "parDenominator": 15795 if value != nil { 15796 jtv, ok := value.(json.Number) 15797 if !ok { 15798 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 15799 } 15800 i64, err := jtv.Int64() 15801 if err != nil { 15802 return err 15803 } 15804 sv.ParDenominator = int32(i64) 15805 } 15806 15807 case "parNumerator": 15808 if value != nil { 15809 jtv, ok := value.(json.Number) 15810 if !ok { 15811 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 15812 } 15813 i64, err := jtv.Int64() 15814 if err != nil { 15815 return err 15816 } 15817 sv.ParNumerator = int32(i64) 15818 } 15819 15820 case "qualityTuningLevel": 15821 if value != nil { 15822 jtv, ok := value.(string) 15823 if !ok { 15824 return fmt.Errorf("expected Mpeg2QualityTuningLevel to be of type string, got %T instead", value) 15825 } 15826 sv.QualityTuningLevel = types.Mpeg2QualityTuningLevel(jtv) 15827 } 15828 15829 case "rateControlMode": 15830 if value != nil { 15831 jtv, ok := value.(string) 15832 if !ok { 15833 return fmt.Errorf("expected Mpeg2RateControlMode to be of type string, got %T instead", value) 15834 } 15835 sv.RateControlMode = types.Mpeg2RateControlMode(jtv) 15836 } 15837 15838 case "scanTypeConversionMode": 15839 if value != nil { 15840 jtv, ok := value.(string) 15841 if !ok { 15842 return fmt.Errorf("expected Mpeg2ScanTypeConversionMode to be of type string, got %T instead", value) 15843 } 15844 sv.ScanTypeConversionMode = types.Mpeg2ScanTypeConversionMode(jtv) 15845 } 15846 15847 case "sceneChangeDetect": 15848 if value != nil { 15849 jtv, ok := value.(string) 15850 if !ok { 15851 return fmt.Errorf("expected Mpeg2SceneChangeDetect to be of type string, got %T instead", value) 15852 } 15853 sv.SceneChangeDetect = types.Mpeg2SceneChangeDetect(jtv) 15854 } 15855 15856 case "slowPal": 15857 if value != nil { 15858 jtv, ok := value.(string) 15859 if !ok { 15860 return fmt.Errorf("expected Mpeg2SlowPal to be of type string, got %T instead", value) 15861 } 15862 sv.SlowPal = types.Mpeg2SlowPal(jtv) 15863 } 15864 15865 case "softness": 15866 if value != nil { 15867 jtv, ok := value.(json.Number) 15868 if !ok { 15869 return fmt.Errorf("expected __integerMin0Max128 to be json.Number, got %T instead", value) 15870 } 15871 i64, err := jtv.Int64() 15872 if err != nil { 15873 return err 15874 } 15875 sv.Softness = int32(i64) 15876 } 15877 15878 case "spatialAdaptiveQuantization": 15879 if value != nil { 15880 jtv, ok := value.(string) 15881 if !ok { 15882 return fmt.Errorf("expected Mpeg2SpatialAdaptiveQuantization to be of type string, got %T instead", value) 15883 } 15884 sv.SpatialAdaptiveQuantization = types.Mpeg2SpatialAdaptiveQuantization(jtv) 15885 } 15886 15887 case "syntax": 15888 if value != nil { 15889 jtv, ok := value.(string) 15890 if !ok { 15891 return fmt.Errorf("expected Mpeg2Syntax to be of type string, got %T instead", value) 15892 } 15893 sv.Syntax = types.Mpeg2Syntax(jtv) 15894 } 15895 15896 case "telecine": 15897 if value != nil { 15898 jtv, ok := value.(string) 15899 if !ok { 15900 return fmt.Errorf("expected Mpeg2Telecine to be of type string, got %T instead", value) 15901 } 15902 sv.Telecine = types.Mpeg2Telecine(jtv) 15903 } 15904 15905 case "temporalAdaptiveQuantization": 15906 if value != nil { 15907 jtv, ok := value.(string) 15908 if !ok { 15909 return fmt.Errorf("expected Mpeg2TemporalAdaptiveQuantization to be of type string, got %T instead", value) 15910 } 15911 sv.TemporalAdaptiveQuantization = types.Mpeg2TemporalAdaptiveQuantization(jtv) 15912 } 15913 15914 default: 15915 _, _ = key, value 15916 15917 } 15918 } 15919 *v = sv 15920 return nil 15921} 15922 15923func awsRestjson1_deserializeDocumentMsSmoothAdditionalManifest(v **types.MsSmoothAdditionalManifest, value interface{}) error { 15924 if v == nil { 15925 return fmt.Errorf("unexpected nil of type %T", v) 15926 } 15927 if value == nil { 15928 return nil 15929 } 15930 15931 shape, ok := value.(map[string]interface{}) 15932 if !ok { 15933 return fmt.Errorf("unexpected JSON type %v", value) 15934 } 15935 15936 var sv *types.MsSmoothAdditionalManifest 15937 if *v == nil { 15938 sv = &types.MsSmoothAdditionalManifest{} 15939 } else { 15940 sv = *v 15941 } 15942 15943 for key, value := range shape { 15944 switch key { 15945 case "manifestNameModifier": 15946 if value != nil { 15947 jtv, ok := value.(string) 15948 if !ok { 15949 return fmt.Errorf("expected __stringMin1 to be of type string, got %T instead", value) 15950 } 15951 sv.ManifestNameModifier = ptr.String(jtv) 15952 } 15953 15954 case "selectedOutputs": 15955 if err := awsRestjson1_deserializeDocument__listOf__stringMin1(&sv.SelectedOutputs, value); err != nil { 15956 return err 15957 } 15958 15959 default: 15960 _, _ = key, value 15961 15962 } 15963 } 15964 *v = sv 15965 return nil 15966} 15967 15968func awsRestjson1_deserializeDocumentMsSmoothEncryptionSettings(v **types.MsSmoothEncryptionSettings, value interface{}) error { 15969 if v == nil { 15970 return fmt.Errorf("unexpected nil of type %T", v) 15971 } 15972 if value == nil { 15973 return nil 15974 } 15975 15976 shape, ok := value.(map[string]interface{}) 15977 if !ok { 15978 return fmt.Errorf("unexpected JSON type %v", value) 15979 } 15980 15981 var sv *types.MsSmoothEncryptionSettings 15982 if *v == nil { 15983 sv = &types.MsSmoothEncryptionSettings{} 15984 } else { 15985 sv = *v 15986 } 15987 15988 for key, value := range shape { 15989 switch key { 15990 case "spekeKeyProvider": 15991 if err := awsRestjson1_deserializeDocumentSpekeKeyProvider(&sv.SpekeKeyProvider, value); err != nil { 15992 return err 15993 } 15994 15995 default: 15996 _, _ = key, value 15997 15998 } 15999 } 16000 *v = sv 16001 return nil 16002} 16003 16004func awsRestjson1_deserializeDocumentMsSmoothGroupSettings(v **types.MsSmoothGroupSettings, value interface{}) error { 16005 if v == nil { 16006 return fmt.Errorf("unexpected nil of type %T", v) 16007 } 16008 if value == nil { 16009 return nil 16010 } 16011 16012 shape, ok := value.(map[string]interface{}) 16013 if !ok { 16014 return fmt.Errorf("unexpected JSON type %v", value) 16015 } 16016 16017 var sv *types.MsSmoothGroupSettings 16018 if *v == nil { 16019 sv = &types.MsSmoothGroupSettings{} 16020 } else { 16021 sv = *v 16022 } 16023 16024 for key, value := range shape { 16025 switch key { 16026 case "additionalManifests": 16027 if err := awsRestjson1_deserializeDocument__listOfMsSmoothAdditionalManifest(&sv.AdditionalManifests, value); err != nil { 16028 return err 16029 } 16030 16031 case "audioDeduplication": 16032 if value != nil { 16033 jtv, ok := value.(string) 16034 if !ok { 16035 return fmt.Errorf("expected MsSmoothAudioDeduplication to be of type string, got %T instead", value) 16036 } 16037 sv.AudioDeduplication = types.MsSmoothAudioDeduplication(jtv) 16038 } 16039 16040 case "destination": 16041 if value != nil { 16042 jtv, ok := value.(string) 16043 if !ok { 16044 return fmt.Errorf("expected __stringPatternS3 to be of type string, got %T instead", value) 16045 } 16046 sv.Destination = ptr.String(jtv) 16047 } 16048 16049 case "destinationSettings": 16050 if err := awsRestjson1_deserializeDocumentDestinationSettings(&sv.DestinationSettings, value); err != nil { 16051 return err 16052 } 16053 16054 case "encryption": 16055 if err := awsRestjson1_deserializeDocumentMsSmoothEncryptionSettings(&sv.Encryption, value); err != nil { 16056 return err 16057 } 16058 16059 case "fragmentLength": 16060 if value != nil { 16061 jtv, ok := value.(json.Number) 16062 if !ok { 16063 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 16064 } 16065 i64, err := jtv.Int64() 16066 if err != nil { 16067 return err 16068 } 16069 sv.FragmentLength = int32(i64) 16070 } 16071 16072 case "fragmentLengthControl": 16073 if value != nil { 16074 jtv, ok := value.(string) 16075 if !ok { 16076 return fmt.Errorf("expected MsSmoothFragmentLengthControl to be of type string, got %T instead", value) 16077 } 16078 sv.FragmentLengthControl = types.MsSmoothFragmentLengthControl(jtv) 16079 } 16080 16081 case "manifestEncoding": 16082 if value != nil { 16083 jtv, ok := value.(string) 16084 if !ok { 16085 return fmt.Errorf("expected MsSmoothManifestEncoding to be of type string, got %T instead", value) 16086 } 16087 sv.ManifestEncoding = types.MsSmoothManifestEncoding(jtv) 16088 } 16089 16090 default: 16091 _, _ = key, value 16092 16093 } 16094 } 16095 *v = sv 16096 return nil 16097} 16098 16099func awsRestjson1_deserializeDocumentMxfSettings(v **types.MxfSettings, value interface{}) error { 16100 if v == nil { 16101 return fmt.Errorf("unexpected nil of type %T", v) 16102 } 16103 if value == nil { 16104 return nil 16105 } 16106 16107 shape, ok := value.(map[string]interface{}) 16108 if !ok { 16109 return fmt.Errorf("unexpected JSON type %v", value) 16110 } 16111 16112 var sv *types.MxfSettings 16113 if *v == nil { 16114 sv = &types.MxfSettings{} 16115 } else { 16116 sv = *v 16117 } 16118 16119 for key, value := range shape { 16120 switch key { 16121 case "afdSignaling": 16122 if value != nil { 16123 jtv, ok := value.(string) 16124 if !ok { 16125 return fmt.Errorf("expected MxfAfdSignaling to be of type string, got %T instead", value) 16126 } 16127 sv.AfdSignaling = types.MxfAfdSignaling(jtv) 16128 } 16129 16130 case "profile": 16131 if value != nil { 16132 jtv, ok := value.(string) 16133 if !ok { 16134 return fmt.Errorf("expected MxfProfile to be of type string, got %T instead", value) 16135 } 16136 sv.Profile = types.MxfProfile(jtv) 16137 } 16138 16139 case "xavcProfileSettings": 16140 if err := awsRestjson1_deserializeDocumentMxfXavcProfileSettings(&sv.XavcProfileSettings, value); err != nil { 16141 return err 16142 } 16143 16144 default: 16145 _, _ = key, value 16146 16147 } 16148 } 16149 *v = sv 16150 return nil 16151} 16152 16153func awsRestjson1_deserializeDocumentMxfXavcProfileSettings(v **types.MxfXavcProfileSettings, value interface{}) error { 16154 if v == nil { 16155 return fmt.Errorf("unexpected nil of type %T", v) 16156 } 16157 if value == nil { 16158 return nil 16159 } 16160 16161 shape, ok := value.(map[string]interface{}) 16162 if !ok { 16163 return fmt.Errorf("unexpected JSON type %v", value) 16164 } 16165 16166 var sv *types.MxfXavcProfileSettings 16167 if *v == nil { 16168 sv = &types.MxfXavcProfileSettings{} 16169 } else { 16170 sv = *v 16171 } 16172 16173 for key, value := range shape { 16174 switch key { 16175 case "durationMode": 16176 if value != nil { 16177 jtv, ok := value.(string) 16178 if !ok { 16179 return fmt.Errorf("expected MxfXavcDurationMode to be of type string, got %T instead", value) 16180 } 16181 sv.DurationMode = types.MxfXavcDurationMode(jtv) 16182 } 16183 16184 case "maxAncDataSize": 16185 if value != nil { 16186 jtv, ok := value.(json.Number) 16187 if !ok { 16188 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 16189 } 16190 i64, err := jtv.Int64() 16191 if err != nil { 16192 return err 16193 } 16194 sv.MaxAncDataSize = int32(i64) 16195 } 16196 16197 default: 16198 _, _ = key, value 16199 16200 } 16201 } 16202 *v = sv 16203 return nil 16204} 16205 16206func awsRestjson1_deserializeDocumentNexGuardFileMarkerSettings(v **types.NexGuardFileMarkerSettings, value interface{}) error { 16207 if v == nil { 16208 return fmt.Errorf("unexpected nil of type %T", v) 16209 } 16210 if value == nil { 16211 return nil 16212 } 16213 16214 shape, ok := value.(map[string]interface{}) 16215 if !ok { 16216 return fmt.Errorf("unexpected JSON type %v", value) 16217 } 16218 16219 var sv *types.NexGuardFileMarkerSettings 16220 if *v == nil { 16221 sv = &types.NexGuardFileMarkerSettings{} 16222 } else { 16223 sv = *v 16224 } 16225 16226 for key, value := range shape { 16227 switch key { 16228 case "license": 16229 if value != nil { 16230 jtv, ok := value.(string) 16231 if !ok { 16232 return fmt.Errorf("expected __stringMin1Max100000 to be of type string, got %T instead", value) 16233 } 16234 sv.License = ptr.String(jtv) 16235 } 16236 16237 case "payload": 16238 if value != nil { 16239 jtv, ok := value.(json.Number) 16240 if !ok { 16241 return fmt.Errorf("expected __integerMin0Max4194303 to be json.Number, got %T instead", value) 16242 } 16243 i64, err := jtv.Int64() 16244 if err != nil { 16245 return err 16246 } 16247 sv.Payload = int32(i64) 16248 } 16249 16250 case "preset": 16251 if value != nil { 16252 jtv, ok := value.(string) 16253 if !ok { 16254 return fmt.Errorf("expected __stringMin1Max256 to be of type string, got %T instead", value) 16255 } 16256 sv.Preset = ptr.String(jtv) 16257 } 16258 16259 case "strength": 16260 if value != nil { 16261 jtv, ok := value.(string) 16262 if !ok { 16263 return fmt.Errorf("expected WatermarkingStrength to be of type string, got %T instead", value) 16264 } 16265 sv.Strength = types.WatermarkingStrength(jtv) 16266 } 16267 16268 default: 16269 _, _ = key, value 16270 16271 } 16272 } 16273 *v = sv 16274 return nil 16275} 16276 16277func awsRestjson1_deserializeDocumentNielsenConfiguration(v **types.NielsenConfiguration, value interface{}) error { 16278 if v == nil { 16279 return fmt.Errorf("unexpected nil of type %T", v) 16280 } 16281 if value == nil { 16282 return nil 16283 } 16284 16285 shape, ok := value.(map[string]interface{}) 16286 if !ok { 16287 return fmt.Errorf("unexpected JSON type %v", value) 16288 } 16289 16290 var sv *types.NielsenConfiguration 16291 if *v == nil { 16292 sv = &types.NielsenConfiguration{} 16293 } else { 16294 sv = *v 16295 } 16296 16297 for key, value := range shape { 16298 switch key { 16299 case "breakoutCode": 16300 if value != nil { 16301 jtv, ok := value.(json.Number) 16302 if !ok { 16303 return fmt.Errorf("expected __integerMin0Max0 to be json.Number, got %T instead", value) 16304 } 16305 i64, err := jtv.Int64() 16306 if err != nil { 16307 return err 16308 } 16309 sv.BreakoutCode = int32(i64) 16310 } 16311 16312 case "distributorId": 16313 if value != nil { 16314 jtv, ok := value.(string) 16315 if !ok { 16316 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 16317 } 16318 sv.DistributorId = ptr.String(jtv) 16319 } 16320 16321 default: 16322 _, _ = key, value 16323 16324 } 16325 } 16326 *v = sv 16327 return nil 16328} 16329 16330func awsRestjson1_deserializeDocumentNielsenNonLinearWatermarkSettings(v **types.NielsenNonLinearWatermarkSettings, value interface{}) error { 16331 if v == nil { 16332 return fmt.Errorf("unexpected nil of type %T", v) 16333 } 16334 if value == nil { 16335 return nil 16336 } 16337 16338 shape, ok := value.(map[string]interface{}) 16339 if !ok { 16340 return fmt.Errorf("unexpected JSON type %v", value) 16341 } 16342 16343 var sv *types.NielsenNonLinearWatermarkSettings 16344 if *v == nil { 16345 sv = &types.NielsenNonLinearWatermarkSettings{} 16346 } else { 16347 sv = *v 16348 } 16349 16350 for key, value := range shape { 16351 switch key { 16352 case "activeWatermarkProcess": 16353 if value != nil { 16354 jtv, ok := value.(string) 16355 if !ok { 16356 return fmt.Errorf("expected NielsenActiveWatermarkProcessType to be of type string, got %T instead", value) 16357 } 16358 sv.ActiveWatermarkProcess = types.NielsenActiveWatermarkProcessType(jtv) 16359 } 16360 16361 case "adiFilename": 16362 if value != nil { 16363 jtv, ok := value.(string) 16364 if !ok { 16365 return fmt.Errorf("expected __stringPatternS3 to be of type string, got %T instead", value) 16366 } 16367 sv.AdiFilename = ptr.String(jtv) 16368 } 16369 16370 case "assetId": 16371 if value != nil { 16372 jtv, ok := value.(string) 16373 if !ok { 16374 return fmt.Errorf("expected __stringMin1Max20 to be of type string, got %T instead", value) 16375 } 16376 sv.AssetId = ptr.String(jtv) 16377 } 16378 16379 case "assetName": 16380 if value != nil { 16381 jtv, ok := value.(string) 16382 if !ok { 16383 return fmt.Errorf("expected __stringMin1Max50 to be of type string, got %T instead", value) 16384 } 16385 sv.AssetName = ptr.String(jtv) 16386 } 16387 16388 case "cbetSourceId": 16389 if value != nil { 16390 jtv, ok := value.(string) 16391 if !ok { 16392 return fmt.Errorf("expected __stringPattern0xAFaF0908190908 to be of type string, got %T instead", value) 16393 } 16394 sv.CbetSourceId = ptr.String(jtv) 16395 } 16396 16397 case "episodeId": 16398 if value != nil { 16399 jtv, ok := value.(string) 16400 if !ok { 16401 return fmt.Errorf("expected __stringMin1Max20 to be of type string, got %T instead", value) 16402 } 16403 sv.EpisodeId = ptr.String(jtv) 16404 } 16405 16406 case "metadataDestination": 16407 if value != nil { 16408 jtv, ok := value.(string) 16409 if !ok { 16410 return fmt.Errorf("expected __stringPatternS3 to be of type string, got %T instead", value) 16411 } 16412 sv.MetadataDestination = ptr.String(jtv) 16413 } 16414 16415 case "sourceId": 16416 if value != nil { 16417 jtv, ok := value.(json.Number) 16418 if !ok { 16419 return fmt.Errorf("expected __integerMin0Max65534 to be json.Number, got %T instead", value) 16420 } 16421 i64, err := jtv.Int64() 16422 if err != nil { 16423 return err 16424 } 16425 sv.SourceId = int32(i64) 16426 } 16427 16428 case "sourceWatermarkStatus": 16429 if value != nil { 16430 jtv, ok := value.(string) 16431 if !ok { 16432 return fmt.Errorf("expected NielsenSourceWatermarkStatusType to be of type string, got %T instead", value) 16433 } 16434 sv.SourceWatermarkStatus = types.NielsenSourceWatermarkStatusType(jtv) 16435 } 16436 16437 case "ticServerUrl": 16438 if value != nil { 16439 jtv, ok := value.(string) 16440 if !ok { 16441 return fmt.Errorf("expected __stringPatternHttps to be of type string, got %T instead", value) 16442 } 16443 sv.TicServerUrl = ptr.String(jtv) 16444 } 16445 16446 case "uniqueTicPerAudioTrack": 16447 if value != nil { 16448 jtv, ok := value.(string) 16449 if !ok { 16450 return fmt.Errorf("expected NielsenUniqueTicPerAudioTrackType to be of type string, got %T instead", value) 16451 } 16452 sv.UniqueTicPerAudioTrack = types.NielsenUniqueTicPerAudioTrackType(jtv) 16453 } 16454 16455 default: 16456 _, _ = key, value 16457 16458 } 16459 } 16460 *v = sv 16461 return nil 16462} 16463 16464func awsRestjson1_deserializeDocumentNoiseReducer(v **types.NoiseReducer, value interface{}) error { 16465 if v == nil { 16466 return fmt.Errorf("unexpected nil of type %T", v) 16467 } 16468 if value == nil { 16469 return nil 16470 } 16471 16472 shape, ok := value.(map[string]interface{}) 16473 if !ok { 16474 return fmt.Errorf("unexpected JSON type %v", value) 16475 } 16476 16477 var sv *types.NoiseReducer 16478 if *v == nil { 16479 sv = &types.NoiseReducer{} 16480 } else { 16481 sv = *v 16482 } 16483 16484 for key, value := range shape { 16485 switch key { 16486 case "filter": 16487 if value != nil { 16488 jtv, ok := value.(string) 16489 if !ok { 16490 return fmt.Errorf("expected NoiseReducerFilter to be of type string, got %T instead", value) 16491 } 16492 sv.Filter = types.NoiseReducerFilter(jtv) 16493 } 16494 16495 case "filterSettings": 16496 if err := awsRestjson1_deserializeDocumentNoiseReducerFilterSettings(&sv.FilterSettings, value); err != nil { 16497 return err 16498 } 16499 16500 case "spatialFilterSettings": 16501 if err := awsRestjson1_deserializeDocumentNoiseReducerSpatialFilterSettings(&sv.SpatialFilterSettings, value); err != nil { 16502 return err 16503 } 16504 16505 case "temporalFilterSettings": 16506 if err := awsRestjson1_deserializeDocumentNoiseReducerTemporalFilterSettings(&sv.TemporalFilterSettings, value); err != nil { 16507 return err 16508 } 16509 16510 default: 16511 _, _ = key, value 16512 16513 } 16514 } 16515 *v = sv 16516 return nil 16517} 16518 16519func awsRestjson1_deserializeDocumentNoiseReducerFilterSettings(v **types.NoiseReducerFilterSettings, value interface{}) error { 16520 if v == nil { 16521 return fmt.Errorf("unexpected nil of type %T", v) 16522 } 16523 if value == nil { 16524 return nil 16525 } 16526 16527 shape, ok := value.(map[string]interface{}) 16528 if !ok { 16529 return fmt.Errorf("unexpected JSON type %v", value) 16530 } 16531 16532 var sv *types.NoiseReducerFilterSettings 16533 if *v == nil { 16534 sv = &types.NoiseReducerFilterSettings{} 16535 } else { 16536 sv = *v 16537 } 16538 16539 for key, value := range shape { 16540 switch key { 16541 case "strength": 16542 if value != nil { 16543 jtv, ok := value.(json.Number) 16544 if !ok { 16545 return fmt.Errorf("expected __integerMin0Max3 to be json.Number, got %T instead", value) 16546 } 16547 i64, err := jtv.Int64() 16548 if err != nil { 16549 return err 16550 } 16551 sv.Strength = int32(i64) 16552 } 16553 16554 default: 16555 _, _ = key, value 16556 16557 } 16558 } 16559 *v = sv 16560 return nil 16561} 16562 16563func awsRestjson1_deserializeDocumentNoiseReducerSpatialFilterSettings(v **types.NoiseReducerSpatialFilterSettings, value interface{}) error { 16564 if v == nil { 16565 return fmt.Errorf("unexpected nil of type %T", v) 16566 } 16567 if value == nil { 16568 return nil 16569 } 16570 16571 shape, ok := value.(map[string]interface{}) 16572 if !ok { 16573 return fmt.Errorf("unexpected JSON type %v", value) 16574 } 16575 16576 var sv *types.NoiseReducerSpatialFilterSettings 16577 if *v == nil { 16578 sv = &types.NoiseReducerSpatialFilterSettings{} 16579 } else { 16580 sv = *v 16581 } 16582 16583 for key, value := range shape { 16584 switch key { 16585 case "postFilterSharpenStrength": 16586 if value != nil { 16587 jtv, ok := value.(json.Number) 16588 if !ok { 16589 return fmt.Errorf("expected __integerMin0Max3 to be json.Number, got %T instead", value) 16590 } 16591 i64, err := jtv.Int64() 16592 if err != nil { 16593 return err 16594 } 16595 sv.PostFilterSharpenStrength = int32(i64) 16596 } 16597 16598 case "speed": 16599 if value != nil { 16600 jtv, ok := value.(json.Number) 16601 if !ok { 16602 return fmt.Errorf("expected __integerMinNegative2Max3 to be json.Number, got %T instead", value) 16603 } 16604 i64, err := jtv.Int64() 16605 if err != nil { 16606 return err 16607 } 16608 sv.Speed = int32(i64) 16609 } 16610 16611 case "strength": 16612 if value != nil { 16613 jtv, ok := value.(json.Number) 16614 if !ok { 16615 return fmt.Errorf("expected __integerMin0Max16 to be json.Number, got %T instead", value) 16616 } 16617 i64, err := jtv.Int64() 16618 if err != nil { 16619 return err 16620 } 16621 sv.Strength = int32(i64) 16622 } 16623 16624 default: 16625 _, _ = key, value 16626 16627 } 16628 } 16629 *v = sv 16630 return nil 16631} 16632 16633func awsRestjson1_deserializeDocumentNoiseReducerTemporalFilterSettings(v **types.NoiseReducerTemporalFilterSettings, value interface{}) error { 16634 if v == nil { 16635 return fmt.Errorf("unexpected nil of type %T", v) 16636 } 16637 if value == nil { 16638 return nil 16639 } 16640 16641 shape, ok := value.(map[string]interface{}) 16642 if !ok { 16643 return fmt.Errorf("unexpected JSON type %v", value) 16644 } 16645 16646 var sv *types.NoiseReducerTemporalFilterSettings 16647 if *v == nil { 16648 sv = &types.NoiseReducerTemporalFilterSettings{} 16649 } else { 16650 sv = *v 16651 } 16652 16653 for key, value := range shape { 16654 switch key { 16655 case "aggressiveMode": 16656 if value != nil { 16657 jtv, ok := value.(json.Number) 16658 if !ok { 16659 return fmt.Errorf("expected __integerMin0Max4 to be json.Number, got %T instead", value) 16660 } 16661 i64, err := jtv.Int64() 16662 if err != nil { 16663 return err 16664 } 16665 sv.AggressiveMode = int32(i64) 16666 } 16667 16668 case "postTemporalSharpening": 16669 if value != nil { 16670 jtv, ok := value.(string) 16671 if !ok { 16672 return fmt.Errorf("expected NoiseFilterPostTemporalSharpening to be of type string, got %T instead", value) 16673 } 16674 sv.PostTemporalSharpening = types.NoiseFilterPostTemporalSharpening(jtv) 16675 } 16676 16677 case "speed": 16678 if value != nil { 16679 jtv, ok := value.(json.Number) 16680 if !ok { 16681 return fmt.Errorf("expected __integerMinNegative1Max3 to be json.Number, got %T instead", value) 16682 } 16683 i64, err := jtv.Int64() 16684 if err != nil { 16685 return err 16686 } 16687 sv.Speed = int32(i64) 16688 } 16689 16690 case "strength": 16691 if value != nil { 16692 jtv, ok := value.(json.Number) 16693 if !ok { 16694 return fmt.Errorf("expected __integerMin0Max16 to be json.Number, got %T instead", value) 16695 } 16696 i64, err := jtv.Int64() 16697 if err != nil { 16698 return err 16699 } 16700 sv.Strength = int32(i64) 16701 } 16702 16703 default: 16704 _, _ = key, value 16705 16706 } 16707 } 16708 *v = sv 16709 return nil 16710} 16711 16712func awsRestjson1_deserializeDocumentNotFoundException(v **types.NotFoundException, value interface{}) error { 16713 if v == nil { 16714 return fmt.Errorf("unexpected nil of type %T", v) 16715 } 16716 if value == nil { 16717 return nil 16718 } 16719 16720 shape, ok := value.(map[string]interface{}) 16721 if !ok { 16722 return fmt.Errorf("unexpected JSON type %v", value) 16723 } 16724 16725 var sv *types.NotFoundException 16726 if *v == nil { 16727 sv = &types.NotFoundException{} 16728 } else { 16729 sv = *v 16730 } 16731 16732 for key, value := range shape { 16733 switch key { 16734 case "message": 16735 if value != nil { 16736 jtv, ok := value.(string) 16737 if !ok { 16738 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 16739 } 16740 sv.Message = ptr.String(jtv) 16741 } 16742 16743 default: 16744 _, _ = key, value 16745 16746 } 16747 } 16748 *v = sv 16749 return nil 16750} 16751 16752func awsRestjson1_deserializeDocumentOpusSettings(v **types.OpusSettings, value interface{}) error { 16753 if v == nil { 16754 return fmt.Errorf("unexpected nil of type %T", v) 16755 } 16756 if value == nil { 16757 return nil 16758 } 16759 16760 shape, ok := value.(map[string]interface{}) 16761 if !ok { 16762 return fmt.Errorf("unexpected JSON type %v", value) 16763 } 16764 16765 var sv *types.OpusSettings 16766 if *v == nil { 16767 sv = &types.OpusSettings{} 16768 } else { 16769 sv = *v 16770 } 16771 16772 for key, value := range shape { 16773 switch key { 16774 case "bitrate": 16775 if value != nil { 16776 jtv, ok := value.(json.Number) 16777 if !ok { 16778 return fmt.Errorf("expected __integerMin32000Max192000 to be json.Number, got %T instead", value) 16779 } 16780 i64, err := jtv.Int64() 16781 if err != nil { 16782 return err 16783 } 16784 sv.Bitrate = int32(i64) 16785 } 16786 16787 case "channels": 16788 if value != nil { 16789 jtv, ok := value.(json.Number) 16790 if !ok { 16791 return fmt.Errorf("expected __integerMin1Max2 to be json.Number, got %T instead", value) 16792 } 16793 i64, err := jtv.Int64() 16794 if err != nil { 16795 return err 16796 } 16797 sv.Channels = int32(i64) 16798 } 16799 16800 case "sampleRate": 16801 if value != nil { 16802 jtv, ok := value.(json.Number) 16803 if !ok { 16804 return fmt.Errorf("expected __integerMin16000Max48000 to be json.Number, got %T instead", value) 16805 } 16806 i64, err := jtv.Int64() 16807 if err != nil { 16808 return err 16809 } 16810 sv.SampleRate = int32(i64) 16811 } 16812 16813 default: 16814 _, _ = key, value 16815 16816 } 16817 } 16818 *v = sv 16819 return nil 16820} 16821 16822func awsRestjson1_deserializeDocumentOutput(v **types.Output, value interface{}) error { 16823 if v == nil { 16824 return fmt.Errorf("unexpected nil of type %T", v) 16825 } 16826 if value == nil { 16827 return nil 16828 } 16829 16830 shape, ok := value.(map[string]interface{}) 16831 if !ok { 16832 return fmt.Errorf("unexpected JSON type %v", value) 16833 } 16834 16835 var sv *types.Output 16836 if *v == nil { 16837 sv = &types.Output{} 16838 } else { 16839 sv = *v 16840 } 16841 16842 for key, value := range shape { 16843 switch key { 16844 case "audioDescriptions": 16845 if err := awsRestjson1_deserializeDocument__listOfAudioDescription(&sv.AudioDescriptions, value); err != nil { 16846 return err 16847 } 16848 16849 case "captionDescriptions": 16850 if err := awsRestjson1_deserializeDocument__listOfCaptionDescription(&sv.CaptionDescriptions, value); err != nil { 16851 return err 16852 } 16853 16854 case "containerSettings": 16855 if err := awsRestjson1_deserializeDocumentContainerSettings(&sv.ContainerSettings, value); err != nil { 16856 return err 16857 } 16858 16859 case "extension": 16860 if value != nil { 16861 jtv, ok := value.(string) 16862 if !ok { 16863 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 16864 } 16865 sv.Extension = ptr.String(jtv) 16866 } 16867 16868 case "nameModifier": 16869 if value != nil { 16870 jtv, ok := value.(string) 16871 if !ok { 16872 return fmt.Errorf("expected __stringMin1 to be of type string, got %T instead", value) 16873 } 16874 sv.NameModifier = ptr.String(jtv) 16875 } 16876 16877 case "outputSettings": 16878 if err := awsRestjson1_deserializeDocumentOutputSettings(&sv.OutputSettings, value); err != nil { 16879 return err 16880 } 16881 16882 case "preset": 16883 if value != nil { 16884 jtv, ok := value.(string) 16885 if !ok { 16886 return fmt.Errorf("expected __stringMin0 to be of type string, got %T instead", value) 16887 } 16888 sv.Preset = ptr.String(jtv) 16889 } 16890 16891 case "videoDescription": 16892 if err := awsRestjson1_deserializeDocumentVideoDescription(&sv.VideoDescription, value); err != nil { 16893 return err 16894 } 16895 16896 default: 16897 _, _ = key, value 16898 16899 } 16900 } 16901 *v = sv 16902 return nil 16903} 16904 16905func awsRestjson1_deserializeDocumentOutputChannelMapping(v **types.OutputChannelMapping, value interface{}) error { 16906 if v == nil { 16907 return fmt.Errorf("unexpected nil of type %T", v) 16908 } 16909 if value == nil { 16910 return nil 16911 } 16912 16913 shape, ok := value.(map[string]interface{}) 16914 if !ok { 16915 return fmt.Errorf("unexpected JSON type %v", value) 16916 } 16917 16918 var sv *types.OutputChannelMapping 16919 if *v == nil { 16920 sv = &types.OutputChannelMapping{} 16921 } else { 16922 sv = *v 16923 } 16924 16925 for key, value := range shape { 16926 switch key { 16927 case "inputChannels": 16928 if err := awsRestjson1_deserializeDocument__listOf__integerMinNegative60Max6(&sv.InputChannels, value); err != nil { 16929 return err 16930 } 16931 16932 case "inputChannelsFineTune": 16933 if err := awsRestjson1_deserializeDocument__listOf__doubleMinNegative60Max6(&sv.InputChannelsFineTune, value); err != nil { 16934 return err 16935 } 16936 16937 default: 16938 _, _ = key, value 16939 16940 } 16941 } 16942 *v = sv 16943 return nil 16944} 16945 16946func awsRestjson1_deserializeDocumentOutputDetail(v **types.OutputDetail, value interface{}) error { 16947 if v == nil { 16948 return fmt.Errorf("unexpected nil of type %T", v) 16949 } 16950 if value == nil { 16951 return nil 16952 } 16953 16954 shape, ok := value.(map[string]interface{}) 16955 if !ok { 16956 return fmt.Errorf("unexpected JSON type %v", value) 16957 } 16958 16959 var sv *types.OutputDetail 16960 if *v == nil { 16961 sv = &types.OutputDetail{} 16962 } else { 16963 sv = *v 16964 } 16965 16966 for key, value := range shape { 16967 switch key { 16968 case "durationInMs": 16969 if value != nil { 16970 jtv, ok := value.(json.Number) 16971 if !ok { 16972 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 16973 } 16974 i64, err := jtv.Int64() 16975 if err != nil { 16976 return err 16977 } 16978 sv.DurationInMs = int32(i64) 16979 } 16980 16981 case "videoDetails": 16982 if err := awsRestjson1_deserializeDocumentVideoDetail(&sv.VideoDetails, value); err != nil { 16983 return err 16984 } 16985 16986 default: 16987 _, _ = key, value 16988 16989 } 16990 } 16991 *v = sv 16992 return nil 16993} 16994 16995func awsRestjson1_deserializeDocumentOutputGroup(v **types.OutputGroup, value interface{}) error { 16996 if v == nil { 16997 return fmt.Errorf("unexpected nil of type %T", v) 16998 } 16999 if value == nil { 17000 return nil 17001 } 17002 17003 shape, ok := value.(map[string]interface{}) 17004 if !ok { 17005 return fmt.Errorf("unexpected JSON type %v", value) 17006 } 17007 17008 var sv *types.OutputGroup 17009 if *v == nil { 17010 sv = &types.OutputGroup{} 17011 } else { 17012 sv = *v 17013 } 17014 17015 for key, value := range shape { 17016 switch key { 17017 case "automatedEncodingSettings": 17018 if err := awsRestjson1_deserializeDocumentAutomatedEncodingSettings(&sv.AutomatedEncodingSettings, value); err != nil { 17019 return err 17020 } 17021 17022 case "customName": 17023 if value != nil { 17024 jtv, ok := value.(string) 17025 if !ok { 17026 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 17027 } 17028 sv.CustomName = ptr.String(jtv) 17029 } 17030 17031 case "name": 17032 if value != nil { 17033 jtv, ok := value.(string) 17034 if !ok { 17035 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 17036 } 17037 sv.Name = ptr.String(jtv) 17038 } 17039 17040 case "outputGroupSettings": 17041 if err := awsRestjson1_deserializeDocumentOutputGroupSettings(&sv.OutputGroupSettings, value); err != nil { 17042 return err 17043 } 17044 17045 case "outputs": 17046 if err := awsRestjson1_deserializeDocument__listOfOutput(&sv.Outputs, value); err != nil { 17047 return err 17048 } 17049 17050 default: 17051 _, _ = key, value 17052 17053 } 17054 } 17055 *v = sv 17056 return nil 17057} 17058 17059func awsRestjson1_deserializeDocumentOutputGroupDetail(v **types.OutputGroupDetail, value interface{}) error { 17060 if v == nil { 17061 return fmt.Errorf("unexpected nil of type %T", v) 17062 } 17063 if value == nil { 17064 return nil 17065 } 17066 17067 shape, ok := value.(map[string]interface{}) 17068 if !ok { 17069 return fmt.Errorf("unexpected JSON type %v", value) 17070 } 17071 17072 var sv *types.OutputGroupDetail 17073 if *v == nil { 17074 sv = &types.OutputGroupDetail{} 17075 } else { 17076 sv = *v 17077 } 17078 17079 for key, value := range shape { 17080 switch key { 17081 case "outputDetails": 17082 if err := awsRestjson1_deserializeDocument__listOfOutputDetail(&sv.OutputDetails, value); err != nil { 17083 return err 17084 } 17085 17086 default: 17087 _, _ = key, value 17088 17089 } 17090 } 17091 *v = sv 17092 return nil 17093} 17094 17095func awsRestjson1_deserializeDocumentOutputGroupSettings(v **types.OutputGroupSettings, value interface{}) error { 17096 if v == nil { 17097 return fmt.Errorf("unexpected nil of type %T", v) 17098 } 17099 if value == nil { 17100 return nil 17101 } 17102 17103 shape, ok := value.(map[string]interface{}) 17104 if !ok { 17105 return fmt.Errorf("unexpected JSON type %v", value) 17106 } 17107 17108 var sv *types.OutputGroupSettings 17109 if *v == nil { 17110 sv = &types.OutputGroupSettings{} 17111 } else { 17112 sv = *v 17113 } 17114 17115 for key, value := range shape { 17116 switch key { 17117 case "cmafGroupSettings": 17118 if err := awsRestjson1_deserializeDocumentCmafGroupSettings(&sv.CmafGroupSettings, value); err != nil { 17119 return err 17120 } 17121 17122 case "dashIsoGroupSettings": 17123 if err := awsRestjson1_deserializeDocumentDashIsoGroupSettings(&sv.DashIsoGroupSettings, value); err != nil { 17124 return err 17125 } 17126 17127 case "fileGroupSettings": 17128 if err := awsRestjson1_deserializeDocumentFileGroupSettings(&sv.FileGroupSettings, value); err != nil { 17129 return err 17130 } 17131 17132 case "hlsGroupSettings": 17133 if err := awsRestjson1_deserializeDocumentHlsGroupSettings(&sv.HlsGroupSettings, value); err != nil { 17134 return err 17135 } 17136 17137 case "msSmoothGroupSettings": 17138 if err := awsRestjson1_deserializeDocumentMsSmoothGroupSettings(&sv.MsSmoothGroupSettings, value); err != nil { 17139 return err 17140 } 17141 17142 case "type": 17143 if value != nil { 17144 jtv, ok := value.(string) 17145 if !ok { 17146 return fmt.Errorf("expected OutputGroupType to be of type string, got %T instead", value) 17147 } 17148 sv.Type = types.OutputGroupType(jtv) 17149 } 17150 17151 default: 17152 _, _ = key, value 17153 17154 } 17155 } 17156 *v = sv 17157 return nil 17158} 17159 17160func awsRestjson1_deserializeDocumentOutputSettings(v **types.OutputSettings, value interface{}) error { 17161 if v == nil { 17162 return fmt.Errorf("unexpected nil of type %T", v) 17163 } 17164 if value == nil { 17165 return nil 17166 } 17167 17168 shape, ok := value.(map[string]interface{}) 17169 if !ok { 17170 return fmt.Errorf("unexpected JSON type %v", value) 17171 } 17172 17173 var sv *types.OutputSettings 17174 if *v == nil { 17175 sv = &types.OutputSettings{} 17176 } else { 17177 sv = *v 17178 } 17179 17180 for key, value := range shape { 17181 switch key { 17182 case "hlsSettings": 17183 if err := awsRestjson1_deserializeDocumentHlsSettings(&sv.HlsSettings, value); err != nil { 17184 return err 17185 } 17186 17187 default: 17188 _, _ = key, value 17189 17190 } 17191 } 17192 *v = sv 17193 return nil 17194} 17195 17196func awsRestjson1_deserializeDocumentPartnerWatermarking(v **types.PartnerWatermarking, value interface{}) error { 17197 if v == nil { 17198 return fmt.Errorf("unexpected nil of type %T", v) 17199 } 17200 if value == nil { 17201 return nil 17202 } 17203 17204 shape, ok := value.(map[string]interface{}) 17205 if !ok { 17206 return fmt.Errorf("unexpected JSON type %v", value) 17207 } 17208 17209 var sv *types.PartnerWatermarking 17210 if *v == nil { 17211 sv = &types.PartnerWatermarking{} 17212 } else { 17213 sv = *v 17214 } 17215 17216 for key, value := range shape { 17217 switch key { 17218 case "nexguardFileMarkerSettings": 17219 if err := awsRestjson1_deserializeDocumentNexGuardFileMarkerSettings(&sv.NexguardFileMarkerSettings, value); err != nil { 17220 return err 17221 } 17222 17223 default: 17224 _, _ = key, value 17225 17226 } 17227 } 17228 *v = sv 17229 return nil 17230} 17231 17232func awsRestjson1_deserializeDocumentPreset(v **types.Preset, value interface{}) error { 17233 if v == nil { 17234 return fmt.Errorf("unexpected nil of type %T", v) 17235 } 17236 if value == nil { 17237 return nil 17238 } 17239 17240 shape, ok := value.(map[string]interface{}) 17241 if !ok { 17242 return fmt.Errorf("unexpected JSON type %v", value) 17243 } 17244 17245 var sv *types.Preset 17246 if *v == nil { 17247 sv = &types.Preset{} 17248 } else { 17249 sv = *v 17250 } 17251 17252 for key, value := range shape { 17253 switch key { 17254 case "arn": 17255 if value != nil { 17256 jtv, ok := value.(string) 17257 if !ok { 17258 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 17259 } 17260 sv.Arn = ptr.String(jtv) 17261 } 17262 17263 case "category": 17264 if value != nil { 17265 jtv, ok := value.(string) 17266 if !ok { 17267 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 17268 } 17269 sv.Category = ptr.String(jtv) 17270 } 17271 17272 case "createdAt": 17273 if value != nil { 17274 switch jtv := value.(type) { 17275 case json.Number: 17276 f64, err := jtv.Float64() 17277 if err != nil { 17278 return err 17279 } 17280 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 17281 17282 default: 17283 return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value) 17284 17285 } 17286 } 17287 17288 case "description": 17289 if value != nil { 17290 jtv, ok := value.(string) 17291 if !ok { 17292 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 17293 } 17294 sv.Description = ptr.String(jtv) 17295 } 17296 17297 case "lastUpdated": 17298 if value != nil { 17299 switch jtv := value.(type) { 17300 case json.Number: 17301 f64, err := jtv.Float64() 17302 if err != nil { 17303 return err 17304 } 17305 sv.LastUpdated = ptr.Time(smithytime.ParseEpochSeconds(f64)) 17306 17307 default: 17308 return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value) 17309 17310 } 17311 } 17312 17313 case "name": 17314 if value != nil { 17315 jtv, ok := value.(string) 17316 if !ok { 17317 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 17318 } 17319 sv.Name = ptr.String(jtv) 17320 } 17321 17322 case "settings": 17323 if err := awsRestjson1_deserializeDocumentPresetSettings(&sv.Settings, value); err != nil { 17324 return err 17325 } 17326 17327 case "type": 17328 if value != nil { 17329 jtv, ok := value.(string) 17330 if !ok { 17331 return fmt.Errorf("expected Type to be of type string, got %T instead", value) 17332 } 17333 sv.Type = types.Type(jtv) 17334 } 17335 17336 default: 17337 _, _ = key, value 17338 17339 } 17340 } 17341 *v = sv 17342 return nil 17343} 17344 17345func awsRestjson1_deserializeDocumentPresetSettings(v **types.PresetSettings, value interface{}) error { 17346 if v == nil { 17347 return fmt.Errorf("unexpected nil of type %T", v) 17348 } 17349 if value == nil { 17350 return nil 17351 } 17352 17353 shape, ok := value.(map[string]interface{}) 17354 if !ok { 17355 return fmt.Errorf("unexpected JSON type %v", value) 17356 } 17357 17358 var sv *types.PresetSettings 17359 if *v == nil { 17360 sv = &types.PresetSettings{} 17361 } else { 17362 sv = *v 17363 } 17364 17365 for key, value := range shape { 17366 switch key { 17367 case "audioDescriptions": 17368 if err := awsRestjson1_deserializeDocument__listOfAudioDescription(&sv.AudioDescriptions, value); err != nil { 17369 return err 17370 } 17371 17372 case "captionDescriptions": 17373 if err := awsRestjson1_deserializeDocument__listOfCaptionDescriptionPreset(&sv.CaptionDescriptions, value); err != nil { 17374 return err 17375 } 17376 17377 case "containerSettings": 17378 if err := awsRestjson1_deserializeDocumentContainerSettings(&sv.ContainerSettings, value); err != nil { 17379 return err 17380 } 17381 17382 case "videoDescription": 17383 if err := awsRestjson1_deserializeDocumentVideoDescription(&sv.VideoDescription, value); err != nil { 17384 return err 17385 } 17386 17387 default: 17388 _, _ = key, value 17389 17390 } 17391 } 17392 *v = sv 17393 return nil 17394} 17395 17396func awsRestjson1_deserializeDocumentProresSettings(v **types.ProresSettings, value interface{}) error { 17397 if v == nil { 17398 return fmt.Errorf("unexpected nil of type %T", v) 17399 } 17400 if value == nil { 17401 return nil 17402 } 17403 17404 shape, ok := value.(map[string]interface{}) 17405 if !ok { 17406 return fmt.Errorf("unexpected JSON type %v", value) 17407 } 17408 17409 var sv *types.ProresSettings 17410 if *v == nil { 17411 sv = &types.ProresSettings{} 17412 } else { 17413 sv = *v 17414 } 17415 17416 for key, value := range shape { 17417 switch key { 17418 case "chromaSampling": 17419 if value != nil { 17420 jtv, ok := value.(string) 17421 if !ok { 17422 return fmt.Errorf("expected ProresChromaSampling to be of type string, got %T instead", value) 17423 } 17424 sv.ChromaSampling = types.ProresChromaSampling(jtv) 17425 } 17426 17427 case "codecProfile": 17428 if value != nil { 17429 jtv, ok := value.(string) 17430 if !ok { 17431 return fmt.Errorf("expected ProresCodecProfile to be of type string, got %T instead", value) 17432 } 17433 sv.CodecProfile = types.ProresCodecProfile(jtv) 17434 } 17435 17436 case "framerateControl": 17437 if value != nil { 17438 jtv, ok := value.(string) 17439 if !ok { 17440 return fmt.Errorf("expected ProresFramerateControl to be of type string, got %T instead", value) 17441 } 17442 sv.FramerateControl = types.ProresFramerateControl(jtv) 17443 } 17444 17445 case "framerateConversionAlgorithm": 17446 if value != nil { 17447 jtv, ok := value.(string) 17448 if !ok { 17449 return fmt.Errorf("expected ProresFramerateConversionAlgorithm to be of type string, got %T instead", value) 17450 } 17451 sv.FramerateConversionAlgorithm = types.ProresFramerateConversionAlgorithm(jtv) 17452 } 17453 17454 case "framerateDenominator": 17455 if value != nil { 17456 jtv, ok := value.(json.Number) 17457 if !ok { 17458 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 17459 } 17460 i64, err := jtv.Int64() 17461 if err != nil { 17462 return err 17463 } 17464 sv.FramerateDenominator = int32(i64) 17465 } 17466 17467 case "framerateNumerator": 17468 if value != nil { 17469 jtv, ok := value.(json.Number) 17470 if !ok { 17471 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 17472 } 17473 i64, err := jtv.Int64() 17474 if err != nil { 17475 return err 17476 } 17477 sv.FramerateNumerator = int32(i64) 17478 } 17479 17480 case "interlaceMode": 17481 if value != nil { 17482 jtv, ok := value.(string) 17483 if !ok { 17484 return fmt.Errorf("expected ProresInterlaceMode to be of type string, got %T instead", value) 17485 } 17486 sv.InterlaceMode = types.ProresInterlaceMode(jtv) 17487 } 17488 17489 case "parControl": 17490 if value != nil { 17491 jtv, ok := value.(string) 17492 if !ok { 17493 return fmt.Errorf("expected ProresParControl to be of type string, got %T instead", value) 17494 } 17495 sv.ParControl = types.ProresParControl(jtv) 17496 } 17497 17498 case "parDenominator": 17499 if value != nil { 17500 jtv, ok := value.(json.Number) 17501 if !ok { 17502 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 17503 } 17504 i64, err := jtv.Int64() 17505 if err != nil { 17506 return err 17507 } 17508 sv.ParDenominator = int32(i64) 17509 } 17510 17511 case "parNumerator": 17512 if value != nil { 17513 jtv, ok := value.(json.Number) 17514 if !ok { 17515 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 17516 } 17517 i64, err := jtv.Int64() 17518 if err != nil { 17519 return err 17520 } 17521 sv.ParNumerator = int32(i64) 17522 } 17523 17524 case "scanTypeConversionMode": 17525 if value != nil { 17526 jtv, ok := value.(string) 17527 if !ok { 17528 return fmt.Errorf("expected ProresScanTypeConversionMode to be of type string, got %T instead", value) 17529 } 17530 sv.ScanTypeConversionMode = types.ProresScanTypeConversionMode(jtv) 17531 } 17532 17533 case "slowPal": 17534 if value != nil { 17535 jtv, ok := value.(string) 17536 if !ok { 17537 return fmt.Errorf("expected ProresSlowPal to be of type string, got %T instead", value) 17538 } 17539 sv.SlowPal = types.ProresSlowPal(jtv) 17540 } 17541 17542 case "telecine": 17543 if value != nil { 17544 jtv, ok := value.(string) 17545 if !ok { 17546 return fmt.Errorf("expected ProresTelecine to be of type string, got %T instead", value) 17547 } 17548 sv.Telecine = types.ProresTelecine(jtv) 17549 } 17550 17551 default: 17552 _, _ = key, value 17553 17554 } 17555 } 17556 *v = sv 17557 return nil 17558} 17559 17560func awsRestjson1_deserializeDocumentQueue(v **types.Queue, value interface{}) error { 17561 if v == nil { 17562 return fmt.Errorf("unexpected nil of type %T", v) 17563 } 17564 if value == nil { 17565 return nil 17566 } 17567 17568 shape, ok := value.(map[string]interface{}) 17569 if !ok { 17570 return fmt.Errorf("unexpected JSON type %v", value) 17571 } 17572 17573 var sv *types.Queue 17574 if *v == nil { 17575 sv = &types.Queue{} 17576 } else { 17577 sv = *v 17578 } 17579 17580 for key, value := range shape { 17581 switch key { 17582 case "arn": 17583 if value != nil { 17584 jtv, ok := value.(string) 17585 if !ok { 17586 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 17587 } 17588 sv.Arn = ptr.String(jtv) 17589 } 17590 17591 case "createdAt": 17592 if value != nil { 17593 switch jtv := value.(type) { 17594 case json.Number: 17595 f64, err := jtv.Float64() 17596 if err != nil { 17597 return err 17598 } 17599 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 17600 17601 default: 17602 return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value) 17603 17604 } 17605 } 17606 17607 case "description": 17608 if value != nil { 17609 jtv, ok := value.(string) 17610 if !ok { 17611 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 17612 } 17613 sv.Description = ptr.String(jtv) 17614 } 17615 17616 case "lastUpdated": 17617 if value != nil { 17618 switch jtv := value.(type) { 17619 case json.Number: 17620 f64, err := jtv.Float64() 17621 if err != nil { 17622 return err 17623 } 17624 sv.LastUpdated = ptr.Time(smithytime.ParseEpochSeconds(f64)) 17625 17626 default: 17627 return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value) 17628 17629 } 17630 } 17631 17632 case "name": 17633 if value != nil { 17634 jtv, ok := value.(string) 17635 if !ok { 17636 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 17637 } 17638 sv.Name = ptr.String(jtv) 17639 } 17640 17641 case "pricingPlan": 17642 if value != nil { 17643 jtv, ok := value.(string) 17644 if !ok { 17645 return fmt.Errorf("expected PricingPlan to be of type string, got %T instead", value) 17646 } 17647 sv.PricingPlan = types.PricingPlan(jtv) 17648 } 17649 17650 case "progressingJobsCount": 17651 if value != nil { 17652 jtv, ok := value.(json.Number) 17653 if !ok { 17654 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 17655 } 17656 i64, err := jtv.Int64() 17657 if err != nil { 17658 return err 17659 } 17660 sv.ProgressingJobsCount = int32(i64) 17661 } 17662 17663 case "reservationPlan": 17664 if err := awsRestjson1_deserializeDocumentReservationPlan(&sv.ReservationPlan, value); err != nil { 17665 return err 17666 } 17667 17668 case "status": 17669 if value != nil { 17670 jtv, ok := value.(string) 17671 if !ok { 17672 return fmt.Errorf("expected QueueStatus to be of type string, got %T instead", value) 17673 } 17674 sv.Status = types.QueueStatus(jtv) 17675 } 17676 17677 case "submittedJobsCount": 17678 if value != nil { 17679 jtv, ok := value.(json.Number) 17680 if !ok { 17681 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 17682 } 17683 i64, err := jtv.Int64() 17684 if err != nil { 17685 return err 17686 } 17687 sv.SubmittedJobsCount = int32(i64) 17688 } 17689 17690 case "type": 17691 if value != nil { 17692 jtv, ok := value.(string) 17693 if !ok { 17694 return fmt.Errorf("expected Type to be of type string, got %T instead", value) 17695 } 17696 sv.Type = types.Type(jtv) 17697 } 17698 17699 default: 17700 _, _ = key, value 17701 17702 } 17703 } 17704 *v = sv 17705 return nil 17706} 17707 17708func awsRestjson1_deserializeDocumentQueueTransition(v **types.QueueTransition, value interface{}) error { 17709 if v == nil { 17710 return fmt.Errorf("unexpected nil of type %T", v) 17711 } 17712 if value == nil { 17713 return nil 17714 } 17715 17716 shape, ok := value.(map[string]interface{}) 17717 if !ok { 17718 return fmt.Errorf("unexpected JSON type %v", value) 17719 } 17720 17721 var sv *types.QueueTransition 17722 if *v == nil { 17723 sv = &types.QueueTransition{} 17724 } else { 17725 sv = *v 17726 } 17727 17728 for key, value := range shape { 17729 switch key { 17730 case "destinationQueue": 17731 if value != nil { 17732 jtv, ok := value.(string) 17733 if !ok { 17734 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 17735 } 17736 sv.DestinationQueue = ptr.String(jtv) 17737 } 17738 17739 case "sourceQueue": 17740 if value != nil { 17741 jtv, ok := value.(string) 17742 if !ok { 17743 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 17744 } 17745 sv.SourceQueue = ptr.String(jtv) 17746 } 17747 17748 case "timestamp": 17749 if value != nil { 17750 switch jtv := value.(type) { 17751 case json.Number: 17752 f64, err := jtv.Float64() 17753 if err != nil { 17754 return err 17755 } 17756 sv.Timestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 17757 17758 default: 17759 return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value) 17760 17761 } 17762 } 17763 17764 default: 17765 _, _ = key, value 17766 17767 } 17768 } 17769 *v = sv 17770 return nil 17771} 17772 17773func awsRestjson1_deserializeDocumentRectangle(v **types.Rectangle, value interface{}) error { 17774 if v == nil { 17775 return fmt.Errorf("unexpected nil of type %T", v) 17776 } 17777 if value == nil { 17778 return nil 17779 } 17780 17781 shape, ok := value.(map[string]interface{}) 17782 if !ok { 17783 return fmt.Errorf("unexpected JSON type %v", value) 17784 } 17785 17786 var sv *types.Rectangle 17787 if *v == nil { 17788 sv = &types.Rectangle{} 17789 } else { 17790 sv = *v 17791 } 17792 17793 for key, value := range shape { 17794 switch key { 17795 case "height": 17796 if value != nil { 17797 jtv, ok := value.(json.Number) 17798 if !ok { 17799 return fmt.Errorf("expected __integerMin2Max2147483647 to be json.Number, got %T instead", value) 17800 } 17801 i64, err := jtv.Int64() 17802 if err != nil { 17803 return err 17804 } 17805 sv.Height = int32(i64) 17806 } 17807 17808 case "width": 17809 if value != nil { 17810 jtv, ok := value.(json.Number) 17811 if !ok { 17812 return fmt.Errorf("expected __integerMin2Max2147483647 to be json.Number, got %T instead", value) 17813 } 17814 i64, err := jtv.Int64() 17815 if err != nil { 17816 return err 17817 } 17818 sv.Width = int32(i64) 17819 } 17820 17821 case "x": 17822 if value != nil { 17823 jtv, ok := value.(json.Number) 17824 if !ok { 17825 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 17826 } 17827 i64, err := jtv.Int64() 17828 if err != nil { 17829 return err 17830 } 17831 sv.X = int32(i64) 17832 } 17833 17834 case "y": 17835 if value != nil { 17836 jtv, ok := value.(json.Number) 17837 if !ok { 17838 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 17839 } 17840 i64, err := jtv.Int64() 17841 if err != nil { 17842 return err 17843 } 17844 sv.Y = int32(i64) 17845 } 17846 17847 default: 17848 _, _ = key, value 17849 17850 } 17851 } 17852 *v = sv 17853 return nil 17854} 17855 17856func awsRestjson1_deserializeDocumentRemixSettings(v **types.RemixSettings, value interface{}) error { 17857 if v == nil { 17858 return fmt.Errorf("unexpected nil of type %T", v) 17859 } 17860 if value == nil { 17861 return nil 17862 } 17863 17864 shape, ok := value.(map[string]interface{}) 17865 if !ok { 17866 return fmt.Errorf("unexpected JSON type %v", value) 17867 } 17868 17869 var sv *types.RemixSettings 17870 if *v == nil { 17871 sv = &types.RemixSettings{} 17872 } else { 17873 sv = *v 17874 } 17875 17876 for key, value := range shape { 17877 switch key { 17878 case "channelMapping": 17879 if err := awsRestjson1_deserializeDocumentChannelMapping(&sv.ChannelMapping, value); err != nil { 17880 return err 17881 } 17882 17883 case "channelsIn": 17884 if value != nil { 17885 jtv, ok := value.(json.Number) 17886 if !ok { 17887 return fmt.Errorf("expected __integerMin1Max64 to be json.Number, got %T instead", value) 17888 } 17889 i64, err := jtv.Int64() 17890 if err != nil { 17891 return err 17892 } 17893 sv.ChannelsIn = int32(i64) 17894 } 17895 17896 case "channelsOut": 17897 if value != nil { 17898 jtv, ok := value.(json.Number) 17899 if !ok { 17900 return fmt.Errorf("expected __integerMin1Max64 to be json.Number, got %T instead", value) 17901 } 17902 i64, err := jtv.Int64() 17903 if err != nil { 17904 return err 17905 } 17906 sv.ChannelsOut = int32(i64) 17907 } 17908 17909 default: 17910 _, _ = key, value 17911 17912 } 17913 } 17914 *v = sv 17915 return nil 17916} 17917 17918func awsRestjson1_deserializeDocumentReservationPlan(v **types.ReservationPlan, value interface{}) error { 17919 if v == nil { 17920 return fmt.Errorf("unexpected nil of type %T", v) 17921 } 17922 if value == nil { 17923 return nil 17924 } 17925 17926 shape, ok := value.(map[string]interface{}) 17927 if !ok { 17928 return fmt.Errorf("unexpected JSON type %v", value) 17929 } 17930 17931 var sv *types.ReservationPlan 17932 if *v == nil { 17933 sv = &types.ReservationPlan{} 17934 } else { 17935 sv = *v 17936 } 17937 17938 for key, value := range shape { 17939 switch key { 17940 case "commitment": 17941 if value != nil { 17942 jtv, ok := value.(string) 17943 if !ok { 17944 return fmt.Errorf("expected Commitment to be of type string, got %T instead", value) 17945 } 17946 sv.Commitment = types.Commitment(jtv) 17947 } 17948 17949 case "expiresAt": 17950 if value != nil { 17951 switch jtv := value.(type) { 17952 case json.Number: 17953 f64, err := jtv.Float64() 17954 if err != nil { 17955 return err 17956 } 17957 sv.ExpiresAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 17958 17959 default: 17960 return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value) 17961 17962 } 17963 } 17964 17965 case "purchasedAt": 17966 if value != nil { 17967 switch jtv := value.(type) { 17968 case json.Number: 17969 f64, err := jtv.Float64() 17970 if err != nil { 17971 return err 17972 } 17973 sv.PurchasedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 17974 17975 default: 17976 return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value) 17977 17978 } 17979 } 17980 17981 case "renewalType": 17982 if value != nil { 17983 jtv, ok := value.(string) 17984 if !ok { 17985 return fmt.Errorf("expected RenewalType to be of type string, got %T instead", value) 17986 } 17987 sv.RenewalType = types.RenewalType(jtv) 17988 } 17989 17990 case "reservedSlots": 17991 if value != nil { 17992 jtv, ok := value.(json.Number) 17993 if !ok { 17994 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 17995 } 17996 i64, err := jtv.Int64() 17997 if err != nil { 17998 return err 17999 } 18000 sv.ReservedSlots = int32(i64) 18001 } 18002 18003 case "status": 18004 if value != nil { 18005 jtv, ok := value.(string) 18006 if !ok { 18007 return fmt.Errorf("expected ReservationPlanStatus to be of type string, got %T instead", value) 18008 } 18009 sv.Status = types.ReservationPlanStatus(jtv) 18010 } 18011 18012 default: 18013 _, _ = key, value 18014 18015 } 18016 } 18017 *v = sv 18018 return nil 18019} 18020 18021func awsRestjson1_deserializeDocumentResourceTags(v **types.ResourceTags, value interface{}) error { 18022 if v == nil { 18023 return fmt.Errorf("unexpected nil of type %T", v) 18024 } 18025 if value == nil { 18026 return nil 18027 } 18028 18029 shape, ok := value.(map[string]interface{}) 18030 if !ok { 18031 return fmt.Errorf("unexpected JSON type %v", value) 18032 } 18033 18034 var sv *types.ResourceTags 18035 if *v == nil { 18036 sv = &types.ResourceTags{} 18037 } else { 18038 sv = *v 18039 } 18040 18041 for key, value := range shape { 18042 switch key { 18043 case "arn": 18044 if value != nil { 18045 jtv, ok := value.(string) 18046 if !ok { 18047 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 18048 } 18049 sv.Arn = ptr.String(jtv) 18050 } 18051 18052 case "tags": 18053 if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil { 18054 return err 18055 } 18056 18057 default: 18058 _, _ = key, value 18059 18060 } 18061 } 18062 *v = sv 18063 return nil 18064} 18065 18066func awsRestjson1_deserializeDocumentS3DestinationAccessControl(v **types.S3DestinationAccessControl, value interface{}) error { 18067 if v == nil { 18068 return fmt.Errorf("unexpected nil of type %T", v) 18069 } 18070 if value == nil { 18071 return nil 18072 } 18073 18074 shape, ok := value.(map[string]interface{}) 18075 if !ok { 18076 return fmt.Errorf("unexpected JSON type %v", value) 18077 } 18078 18079 var sv *types.S3DestinationAccessControl 18080 if *v == nil { 18081 sv = &types.S3DestinationAccessControl{} 18082 } else { 18083 sv = *v 18084 } 18085 18086 for key, value := range shape { 18087 switch key { 18088 case "cannedAcl": 18089 if value != nil { 18090 jtv, ok := value.(string) 18091 if !ok { 18092 return fmt.Errorf("expected S3ObjectCannedAcl to be of type string, got %T instead", value) 18093 } 18094 sv.CannedAcl = types.S3ObjectCannedAcl(jtv) 18095 } 18096 18097 default: 18098 _, _ = key, value 18099 18100 } 18101 } 18102 *v = sv 18103 return nil 18104} 18105 18106func awsRestjson1_deserializeDocumentS3DestinationSettings(v **types.S3DestinationSettings, value interface{}) error { 18107 if v == nil { 18108 return fmt.Errorf("unexpected nil of type %T", v) 18109 } 18110 if value == nil { 18111 return nil 18112 } 18113 18114 shape, ok := value.(map[string]interface{}) 18115 if !ok { 18116 return fmt.Errorf("unexpected JSON type %v", value) 18117 } 18118 18119 var sv *types.S3DestinationSettings 18120 if *v == nil { 18121 sv = &types.S3DestinationSettings{} 18122 } else { 18123 sv = *v 18124 } 18125 18126 for key, value := range shape { 18127 switch key { 18128 case "accessControl": 18129 if err := awsRestjson1_deserializeDocumentS3DestinationAccessControl(&sv.AccessControl, value); err != nil { 18130 return err 18131 } 18132 18133 case "encryption": 18134 if err := awsRestjson1_deserializeDocumentS3EncryptionSettings(&sv.Encryption, value); err != nil { 18135 return err 18136 } 18137 18138 default: 18139 _, _ = key, value 18140 18141 } 18142 } 18143 *v = sv 18144 return nil 18145} 18146 18147func awsRestjson1_deserializeDocumentS3EncryptionSettings(v **types.S3EncryptionSettings, value interface{}) error { 18148 if v == nil { 18149 return fmt.Errorf("unexpected nil of type %T", v) 18150 } 18151 if value == nil { 18152 return nil 18153 } 18154 18155 shape, ok := value.(map[string]interface{}) 18156 if !ok { 18157 return fmt.Errorf("unexpected JSON type %v", value) 18158 } 18159 18160 var sv *types.S3EncryptionSettings 18161 if *v == nil { 18162 sv = &types.S3EncryptionSettings{} 18163 } else { 18164 sv = *v 18165 } 18166 18167 for key, value := range shape { 18168 switch key { 18169 case "encryptionType": 18170 if value != nil { 18171 jtv, ok := value.(string) 18172 if !ok { 18173 return fmt.Errorf("expected S3ServerSideEncryptionType to be of type string, got %T instead", value) 18174 } 18175 sv.EncryptionType = types.S3ServerSideEncryptionType(jtv) 18176 } 18177 18178 case "kmsEncryptionContext": 18179 if value != nil { 18180 jtv, ok := value.(string) 18181 if !ok { 18182 return fmt.Errorf("expected __stringPatternAZaZ0902 to be of type string, got %T instead", value) 18183 } 18184 sv.KmsEncryptionContext = ptr.String(jtv) 18185 } 18186 18187 case "kmsKeyArn": 18188 if value != nil { 18189 jtv, ok := value.(string) 18190 if !ok { 18191 return fmt.Errorf("expected __stringPatternArnAwsUsGovCnKmsAZ26EastWestCentralNorthSouthEastWest1912D12KeyAFAF098AFAF094AFAF094AFAF094AFAF0912 to be of type string, got %T instead", value) 18192 } 18193 sv.KmsKeyArn = ptr.String(jtv) 18194 } 18195 18196 default: 18197 _, _ = key, value 18198 18199 } 18200 } 18201 *v = sv 18202 return nil 18203} 18204 18205func awsRestjson1_deserializeDocumentSccDestinationSettings(v **types.SccDestinationSettings, value interface{}) error { 18206 if v == nil { 18207 return fmt.Errorf("unexpected nil of type %T", v) 18208 } 18209 if value == nil { 18210 return nil 18211 } 18212 18213 shape, ok := value.(map[string]interface{}) 18214 if !ok { 18215 return fmt.Errorf("unexpected JSON type %v", value) 18216 } 18217 18218 var sv *types.SccDestinationSettings 18219 if *v == nil { 18220 sv = &types.SccDestinationSettings{} 18221 } else { 18222 sv = *v 18223 } 18224 18225 for key, value := range shape { 18226 switch key { 18227 case "framerate": 18228 if value != nil { 18229 jtv, ok := value.(string) 18230 if !ok { 18231 return fmt.Errorf("expected SccDestinationFramerate to be of type string, got %T instead", value) 18232 } 18233 sv.Framerate = types.SccDestinationFramerate(jtv) 18234 } 18235 18236 default: 18237 _, _ = key, value 18238 18239 } 18240 } 18241 *v = sv 18242 return nil 18243} 18244 18245func awsRestjson1_deserializeDocumentSpekeKeyProvider(v **types.SpekeKeyProvider, value interface{}) error { 18246 if v == nil { 18247 return fmt.Errorf("unexpected nil of type %T", v) 18248 } 18249 if value == nil { 18250 return nil 18251 } 18252 18253 shape, ok := value.(map[string]interface{}) 18254 if !ok { 18255 return fmt.Errorf("unexpected JSON type %v", value) 18256 } 18257 18258 var sv *types.SpekeKeyProvider 18259 if *v == nil { 18260 sv = &types.SpekeKeyProvider{} 18261 } else { 18262 sv = *v 18263 } 18264 18265 for key, value := range shape { 18266 switch key { 18267 case "certificateArn": 18268 if value != nil { 18269 jtv, ok := value.(string) 18270 if !ok { 18271 return fmt.Errorf("expected __stringPatternArnAwsUsGovAcm to be of type string, got %T instead", value) 18272 } 18273 sv.CertificateArn = ptr.String(jtv) 18274 } 18275 18276 case "resourceId": 18277 if value != nil { 18278 jtv, ok := value.(string) 18279 if !ok { 18280 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 18281 } 18282 sv.ResourceId = ptr.String(jtv) 18283 } 18284 18285 case "systemIds": 18286 if err := awsRestjson1_deserializeDocument__listOf__stringPattern09aFAF809aFAF409aFAF409aFAF409aFAF12(&sv.SystemIds, value); err != nil { 18287 return err 18288 } 18289 18290 case "url": 18291 if value != nil { 18292 jtv, ok := value.(string) 18293 if !ok { 18294 return fmt.Errorf("expected __stringPatternHttps to be of type string, got %T instead", value) 18295 } 18296 sv.Url = ptr.String(jtv) 18297 } 18298 18299 default: 18300 _, _ = key, value 18301 18302 } 18303 } 18304 *v = sv 18305 return nil 18306} 18307 18308func awsRestjson1_deserializeDocumentSpekeKeyProviderCmaf(v **types.SpekeKeyProviderCmaf, value interface{}) error { 18309 if v == nil { 18310 return fmt.Errorf("unexpected nil of type %T", v) 18311 } 18312 if value == nil { 18313 return nil 18314 } 18315 18316 shape, ok := value.(map[string]interface{}) 18317 if !ok { 18318 return fmt.Errorf("unexpected JSON type %v", value) 18319 } 18320 18321 var sv *types.SpekeKeyProviderCmaf 18322 if *v == nil { 18323 sv = &types.SpekeKeyProviderCmaf{} 18324 } else { 18325 sv = *v 18326 } 18327 18328 for key, value := range shape { 18329 switch key { 18330 case "certificateArn": 18331 if value != nil { 18332 jtv, ok := value.(string) 18333 if !ok { 18334 return fmt.Errorf("expected __stringPatternArnAwsUsGovAcm to be of type string, got %T instead", value) 18335 } 18336 sv.CertificateArn = ptr.String(jtv) 18337 } 18338 18339 case "dashSignaledSystemIds": 18340 if err := awsRestjson1_deserializeDocument__listOf__stringMin36Max36Pattern09aFAF809aFAF409aFAF409aFAF409aFAF12(&sv.DashSignaledSystemIds, value); err != nil { 18341 return err 18342 } 18343 18344 case "hlsSignaledSystemIds": 18345 if err := awsRestjson1_deserializeDocument__listOf__stringMin36Max36Pattern09aFAF809aFAF409aFAF409aFAF409aFAF12(&sv.HlsSignaledSystemIds, value); err != nil { 18346 return err 18347 } 18348 18349 case "resourceId": 18350 if value != nil { 18351 jtv, ok := value.(string) 18352 if !ok { 18353 return fmt.Errorf("expected __stringPatternW to be of type string, got %T instead", value) 18354 } 18355 sv.ResourceId = ptr.String(jtv) 18356 } 18357 18358 case "url": 18359 if value != nil { 18360 jtv, ok := value.(string) 18361 if !ok { 18362 return fmt.Errorf("expected __stringPatternHttps to be of type string, got %T instead", value) 18363 } 18364 sv.Url = ptr.String(jtv) 18365 } 18366 18367 default: 18368 _, _ = key, value 18369 18370 } 18371 } 18372 *v = sv 18373 return nil 18374} 18375 18376func awsRestjson1_deserializeDocumentSrtDestinationSettings(v **types.SrtDestinationSettings, value interface{}) error { 18377 if v == nil { 18378 return fmt.Errorf("unexpected nil of type %T", v) 18379 } 18380 if value == nil { 18381 return nil 18382 } 18383 18384 shape, ok := value.(map[string]interface{}) 18385 if !ok { 18386 return fmt.Errorf("unexpected JSON type %v", value) 18387 } 18388 18389 var sv *types.SrtDestinationSettings 18390 if *v == nil { 18391 sv = &types.SrtDestinationSettings{} 18392 } else { 18393 sv = *v 18394 } 18395 18396 for key, value := range shape { 18397 switch key { 18398 case "stylePassthrough": 18399 if value != nil { 18400 jtv, ok := value.(string) 18401 if !ok { 18402 return fmt.Errorf("expected SrtStylePassthrough to be of type string, got %T instead", value) 18403 } 18404 sv.StylePassthrough = types.SrtStylePassthrough(jtv) 18405 } 18406 18407 default: 18408 _, _ = key, value 18409 18410 } 18411 } 18412 *v = sv 18413 return nil 18414} 18415 18416func awsRestjson1_deserializeDocumentStaticKeyProvider(v **types.StaticKeyProvider, value interface{}) error { 18417 if v == nil { 18418 return fmt.Errorf("unexpected nil of type %T", v) 18419 } 18420 if value == nil { 18421 return nil 18422 } 18423 18424 shape, ok := value.(map[string]interface{}) 18425 if !ok { 18426 return fmt.Errorf("unexpected JSON type %v", value) 18427 } 18428 18429 var sv *types.StaticKeyProvider 18430 if *v == nil { 18431 sv = &types.StaticKeyProvider{} 18432 } else { 18433 sv = *v 18434 } 18435 18436 for key, value := range shape { 18437 switch key { 18438 case "keyFormat": 18439 if value != nil { 18440 jtv, ok := value.(string) 18441 if !ok { 18442 return fmt.Errorf("expected __stringPatternIdentityAZaZ26AZaZ09163 to be of type string, got %T instead", value) 18443 } 18444 sv.KeyFormat = ptr.String(jtv) 18445 } 18446 18447 case "keyFormatVersions": 18448 if value != nil { 18449 jtv, ok := value.(string) 18450 if !ok { 18451 return fmt.Errorf("expected __stringPatternDD to be of type string, got %T instead", value) 18452 } 18453 sv.KeyFormatVersions = ptr.String(jtv) 18454 } 18455 18456 case "staticKeyValue": 18457 if value != nil { 18458 jtv, ok := value.(string) 18459 if !ok { 18460 return fmt.Errorf("expected __stringPatternAZaZ0932 to be of type string, got %T instead", value) 18461 } 18462 sv.StaticKeyValue = ptr.String(jtv) 18463 } 18464 18465 case "url": 18466 if value != nil { 18467 jtv, ok := value.(string) 18468 if !ok { 18469 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 18470 } 18471 sv.Url = ptr.String(jtv) 18472 } 18473 18474 default: 18475 _, _ = key, value 18476 18477 } 18478 } 18479 *v = sv 18480 return nil 18481} 18482 18483func awsRestjson1_deserializeDocumentTeletextDestinationSettings(v **types.TeletextDestinationSettings, value interface{}) error { 18484 if v == nil { 18485 return fmt.Errorf("unexpected nil of type %T", v) 18486 } 18487 if value == nil { 18488 return nil 18489 } 18490 18491 shape, ok := value.(map[string]interface{}) 18492 if !ok { 18493 return fmt.Errorf("unexpected JSON type %v", value) 18494 } 18495 18496 var sv *types.TeletextDestinationSettings 18497 if *v == nil { 18498 sv = &types.TeletextDestinationSettings{} 18499 } else { 18500 sv = *v 18501 } 18502 18503 for key, value := range shape { 18504 switch key { 18505 case "pageNumber": 18506 if value != nil { 18507 jtv, ok := value.(string) 18508 if !ok { 18509 return fmt.Errorf("expected __stringMin3Max3Pattern1809aFAF09aEAE to be of type string, got %T instead", value) 18510 } 18511 sv.PageNumber = ptr.String(jtv) 18512 } 18513 18514 case "pageTypes": 18515 if err := awsRestjson1_deserializeDocument__listOfTeletextPageType(&sv.PageTypes, value); err != nil { 18516 return err 18517 } 18518 18519 default: 18520 _, _ = key, value 18521 18522 } 18523 } 18524 *v = sv 18525 return nil 18526} 18527 18528func awsRestjson1_deserializeDocumentTeletextSourceSettings(v **types.TeletextSourceSettings, value interface{}) error { 18529 if v == nil { 18530 return fmt.Errorf("unexpected nil of type %T", v) 18531 } 18532 if value == nil { 18533 return nil 18534 } 18535 18536 shape, ok := value.(map[string]interface{}) 18537 if !ok { 18538 return fmt.Errorf("unexpected JSON type %v", value) 18539 } 18540 18541 var sv *types.TeletextSourceSettings 18542 if *v == nil { 18543 sv = &types.TeletextSourceSettings{} 18544 } else { 18545 sv = *v 18546 } 18547 18548 for key, value := range shape { 18549 switch key { 18550 case "pageNumber": 18551 if value != nil { 18552 jtv, ok := value.(string) 18553 if !ok { 18554 return fmt.Errorf("expected __stringMin3Max3Pattern1809aFAF09aEAE to be of type string, got %T instead", value) 18555 } 18556 sv.PageNumber = ptr.String(jtv) 18557 } 18558 18559 default: 18560 _, _ = key, value 18561 18562 } 18563 } 18564 *v = sv 18565 return nil 18566} 18567 18568func awsRestjson1_deserializeDocumentTimecodeBurnin(v **types.TimecodeBurnin, value interface{}) error { 18569 if v == nil { 18570 return fmt.Errorf("unexpected nil of type %T", v) 18571 } 18572 if value == nil { 18573 return nil 18574 } 18575 18576 shape, ok := value.(map[string]interface{}) 18577 if !ok { 18578 return fmt.Errorf("unexpected JSON type %v", value) 18579 } 18580 18581 var sv *types.TimecodeBurnin 18582 if *v == nil { 18583 sv = &types.TimecodeBurnin{} 18584 } else { 18585 sv = *v 18586 } 18587 18588 for key, value := range shape { 18589 switch key { 18590 case "fontSize": 18591 if value != nil { 18592 jtv, ok := value.(json.Number) 18593 if !ok { 18594 return fmt.Errorf("expected __integerMin10Max48 to be json.Number, got %T instead", value) 18595 } 18596 i64, err := jtv.Int64() 18597 if err != nil { 18598 return err 18599 } 18600 sv.FontSize = int32(i64) 18601 } 18602 18603 case "position": 18604 if value != nil { 18605 jtv, ok := value.(string) 18606 if !ok { 18607 return fmt.Errorf("expected TimecodeBurninPosition to be of type string, got %T instead", value) 18608 } 18609 sv.Position = types.TimecodeBurninPosition(jtv) 18610 } 18611 18612 case "prefix": 18613 if value != nil { 18614 jtv, ok := value.(string) 18615 if !ok { 18616 return fmt.Errorf("expected __stringPattern to be of type string, got %T instead", value) 18617 } 18618 sv.Prefix = ptr.String(jtv) 18619 } 18620 18621 default: 18622 _, _ = key, value 18623 18624 } 18625 } 18626 *v = sv 18627 return nil 18628} 18629 18630func awsRestjson1_deserializeDocumentTimecodeConfig(v **types.TimecodeConfig, value interface{}) error { 18631 if v == nil { 18632 return fmt.Errorf("unexpected nil of type %T", v) 18633 } 18634 if value == nil { 18635 return nil 18636 } 18637 18638 shape, ok := value.(map[string]interface{}) 18639 if !ok { 18640 return fmt.Errorf("unexpected JSON type %v", value) 18641 } 18642 18643 var sv *types.TimecodeConfig 18644 if *v == nil { 18645 sv = &types.TimecodeConfig{} 18646 } else { 18647 sv = *v 18648 } 18649 18650 for key, value := range shape { 18651 switch key { 18652 case "anchor": 18653 if value != nil { 18654 jtv, ok := value.(string) 18655 if !ok { 18656 return fmt.Errorf("expected __stringPattern010920405090509092 to be of type string, got %T instead", value) 18657 } 18658 sv.Anchor = ptr.String(jtv) 18659 } 18660 18661 case "source": 18662 if value != nil { 18663 jtv, ok := value.(string) 18664 if !ok { 18665 return fmt.Errorf("expected TimecodeSource to be of type string, got %T instead", value) 18666 } 18667 sv.Source = types.TimecodeSource(jtv) 18668 } 18669 18670 case "start": 18671 if value != nil { 18672 jtv, ok := value.(string) 18673 if !ok { 18674 return fmt.Errorf("expected __stringPattern010920405090509092 to be of type string, got %T instead", value) 18675 } 18676 sv.Start = ptr.String(jtv) 18677 } 18678 18679 case "timestampOffset": 18680 if value != nil { 18681 jtv, ok := value.(string) 18682 if !ok { 18683 return fmt.Errorf("expected __stringPattern0940191020191209301 to be of type string, got %T instead", value) 18684 } 18685 sv.TimestampOffset = ptr.String(jtv) 18686 } 18687 18688 default: 18689 _, _ = key, value 18690 18691 } 18692 } 18693 *v = sv 18694 return nil 18695} 18696 18697func awsRestjson1_deserializeDocumentTimedMetadataInsertion(v **types.TimedMetadataInsertion, value interface{}) error { 18698 if v == nil { 18699 return fmt.Errorf("unexpected nil of type %T", v) 18700 } 18701 if value == nil { 18702 return nil 18703 } 18704 18705 shape, ok := value.(map[string]interface{}) 18706 if !ok { 18707 return fmt.Errorf("unexpected JSON type %v", value) 18708 } 18709 18710 var sv *types.TimedMetadataInsertion 18711 if *v == nil { 18712 sv = &types.TimedMetadataInsertion{} 18713 } else { 18714 sv = *v 18715 } 18716 18717 for key, value := range shape { 18718 switch key { 18719 case "id3Insertions": 18720 if err := awsRestjson1_deserializeDocument__listOfId3Insertion(&sv.Id3Insertions, value); err != nil { 18721 return err 18722 } 18723 18724 default: 18725 _, _ = key, value 18726 18727 } 18728 } 18729 *v = sv 18730 return nil 18731} 18732 18733func awsRestjson1_deserializeDocumentTiming(v **types.Timing, value interface{}) error { 18734 if v == nil { 18735 return fmt.Errorf("unexpected nil of type %T", v) 18736 } 18737 if value == nil { 18738 return nil 18739 } 18740 18741 shape, ok := value.(map[string]interface{}) 18742 if !ok { 18743 return fmt.Errorf("unexpected JSON type %v", value) 18744 } 18745 18746 var sv *types.Timing 18747 if *v == nil { 18748 sv = &types.Timing{} 18749 } else { 18750 sv = *v 18751 } 18752 18753 for key, value := range shape { 18754 switch key { 18755 case "finishTime": 18756 if value != nil { 18757 switch jtv := value.(type) { 18758 case json.Number: 18759 f64, err := jtv.Float64() 18760 if err != nil { 18761 return err 18762 } 18763 sv.FinishTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 18764 18765 default: 18766 return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value) 18767 18768 } 18769 } 18770 18771 case "startTime": 18772 if value != nil { 18773 switch jtv := value.(type) { 18774 case json.Number: 18775 f64, err := jtv.Float64() 18776 if err != nil { 18777 return err 18778 } 18779 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 18780 18781 default: 18782 return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value) 18783 18784 } 18785 } 18786 18787 case "submitTime": 18788 if value != nil { 18789 switch jtv := value.(type) { 18790 case json.Number: 18791 f64, err := jtv.Float64() 18792 if err != nil { 18793 return err 18794 } 18795 sv.SubmitTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 18796 18797 default: 18798 return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value) 18799 18800 } 18801 } 18802 18803 default: 18804 _, _ = key, value 18805 18806 } 18807 } 18808 *v = sv 18809 return nil 18810} 18811 18812func awsRestjson1_deserializeDocumentTooManyRequestsException(v **types.TooManyRequestsException, value interface{}) error { 18813 if v == nil { 18814 return fmt.Errorf("unexpected nil of type %T", v) 18815 } 18816 if value == nil { 18817 return nil 18818 } 18819 18820 shape, ok := value.(map[string]interface{}) 18821 if !ok { 18822 return fmt.Errorf("unexpected JSON type %v", value) 18823 } 18824 18825 var sv *types.TooManyRequestsException 18826 if *v == nil { 18827 sv = &types.TooManyRequestsException{} 18828 } else { 18829 sv = *v 18830 } 18831 18832 for key, value := range shape { 18833 switch key { 18834 case "message": 18835 if value != nil { 18836 jtv, ok := value.(string) 18837 if !ok { 18838 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 18839 } 18840 sv.Message = ptr.String(jtv) 18841 } 18842 18843 default: 18844 _, _ = key, value 18845 18846 } 18847 } 18848 *v = sv 18849 return nil 18850} 18851 18852func awsRestjson1_deserializeDocumentTrackSourceSettings(v **types.TrackSourceSettings, value interface{}) error { 18853 if v == nil { 18854 return fmt.Errorf("unexpected nil of type %T", v) 18855 } 18856 if value == nil { 18857 return nil 18858 } 18859 18860 shape, ok := value.(map[string]interface{}) 18861 if !ok { 18862 return fmt.Errorf("unexpected JSON type %v", value) 18863 } 18864 18865 var sv *types.TrackSourceSettings 18866 if *v == nil { 18867 sv = &types.TrackSourceSettings{} 18868 } else { 18869 sv = *v 18870 } 18871 18872 for key, value := range shape { 18873 switch key { 18874 case "trackNumber": 18875 if value != nil { 18876 jtv, ok := value.(json.Number) 18877 if !ok { 18878 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 18879 } 18880 i64, err := jtv.Int64() 18881 if err != nil { 18882 return err 18883 } 18884 sv.TrackNumber = int32(i64) 18885 } 18886 18887 default: 18888 _, _ = key, value 18889 18890 } 18891 } 18892 *v = sv 18893 return nil 18894} 18895 18896func awsRestjson1_deserializeDocumentTtmlDestinationSettings(v **types.TtmlDestinationSettings, value interface{}) error { 18897 if v == nil { 18898 return fmt.Errorf("unexpected nil of type %T", v) 18899 } 18900 if value == nil { 18901 return nil 18902 } 18903 18904 shape, ok := value.(map[string]interface{}) 18905 if !ok { 18906 return fmt.Errorf("unexpected JSON type %v", value) 18907 } 18908 18909 var sv *types.TtmlDestinationSettings 18910 if *v == nil { 18911 sv = &types.TtmlDestinationSettings{} 18912 } else { 18913 sv = *v 18914 } 18915 18916 for key, value := range shape { 18917 switch key { 18918 case "stylePassthrough": 18919 if value != nil { 18920 jtv, ok := value.(string) 18921 if !ok { 18922 return fmt.Errorf("expected TtmlStylePassthrough to be of type string, got %T instead", value) 18923 } 18924 sv.StylePassthrough = types.TtmlStylePassthrough(jtv) 18925 } 18926 18927 default: 18928 _, _ = key, value 18929 18930 } 18931 } 18932 *v = sv 18933 return nil 18934} 18935 18936func awsRestjson1_deserializeDocumentVc3Settings(v **types.Vc3Settings, value interface{}) error { 18937 if v == nil { 18938 return fmt.Errorf("unexpected nil of type %T", v) 18939 } 18940 if value == nil { 18941 return nil 18942 } 18943 18944 shape, ok := value.(map[string]interface{}) 18945 if !ok { 18946 return fmt.Errorf("unexpected JSON type %v", value) 18947 } 18948 18949 var sv *types.Vc3Settings 18950 if *v == nil { 18951 sv = &types.Vc3Settings{} 18952 } else { 18953 sv = *v 18954 } 18955 18956 for key, value := range shape { 18957 switch key { 18958 case "framerateControl": 18959 if value != nil { 18960 jtv, ok := value.(string) 18961 if !ok { 18962 return fmt.Errorf("expected Vc3FramerateControl to be of type string, got %T instead", value) 18963 } 18964 sv.FramerateControl = types.Vc3FramerateControl(jtv) 18965 } 18966 18967 case "framerateConversionAlgorithm": 18968 if value != nil { 18969 jtv, ok := value.(string) 18970 if !ok { 18971 return fmt.Errorf("expected Vc3FramerateConversionAlgorithm to be of type string, got %T instead", value) 18972 } 18973 sv.FramerateConversionAlgorithm = types.Vc3FramerateConversionAlgorithm(jtv) 18974 } 18975 18976 case "framerateDenominator": 18977 if value != nil { 18978 jtv, ok := value.(json.Number) 18979 if !ok { 18980 return fmt.Errorf("expected __integerMin1Max1001 to be json.Number, got %T instead", value) 18981 } 18982 i64, err := jtv.Int64() 18983 if err != nil { 18984 return err 18985 } 18986 sv.FramerateDenominator = int32(i64) 18987 } 18988 18989 case "framerateNumerator": 18990 if value != nil { 18991 jtv, ok := value.(json.Number) 18992 if !ok { 18993 return fmt.Errorf("expected __integerMin24Max60000 to be json.Number, got %T instead", value) 18994 } 18995 i64, err := jtv.Int64() 18996 if err != nil { 18997 return err 18998 } 18999 sv.FramerateNumerator = int32(i64) 19000 } 19001 19002 case "interlaceMode": 19003 if value != nil { 19004 jtv, ok := value.(string) 19005 if !ok { 19006 return fmt.Errorf("expected Vc3InterlaceMode to be of type string, got %T instead", value) 19007 } 19008 sv.InterlaceMode = types.Vc3InterlaceMode(jtv) 19009 } 19010 19011 case "scanTypeConversionMode": 19012 if value != nil { 19013 jtv, ok := value.(string) 19014 if !ok { 19015 return fmt.Errorf("expected Vc3ScanTypeConversionMode to be of type string, got %T instead", value) 19016 } 19017 sv.ScanTypeConversionMode = types.Vc3ScanTypeConversionMode(jtv) 19018 } 19019 19020 case "slowPal": 19021 if value != nil { 19022 jtv, ok := value.(string) 19023 if !ok { 19024 return fmt.Errorf("expected Vc3SlowPal to be of type string, got %T instead", value) 19025 } 19026 sv.SlowPal = types.Vc3SlowPal(jtv) 19027 } 19028 19029 case "telecine": 19030 if value != nil { 19031 jtv, ok := value.(string) 19032 if !ok { 19033 return fmt.Errorf("expected Vc3Telecine to be of type string, got %T instead", value) 19034 } 19035 sv.Telecine = types.Vc3Telecine(jtv) 19036 } 19037 19038 case "vc3Class": 19039 if value != nil { 19040 jtv, ok := value.(string) 19041 if !ok { 19042 return fmt.Errorf("expected Vc3Class to be of type string, got %T instead", value) 19043 } 19044 sv.Vc3Class = types.Vc3Class(jtv) 19045 } 19046 19047 default: 19048 _, _ = key, value 19049 19050 } 19051 } 19052 *v = sv 19053 return nil 19054} 19055 19056func awsRestjson1_deserializeDocumentVideoCodecSettings(v **types.VideoCodecSettings, value interface{}) error { 19057 if v == nil { 19058 return fmt.Errorf("unexpected nil of type %T", v) 19059 } 19060 if value == nil { 19061 return nil 19062 } 19063 19064 shape, ok := value.(map[string]interface{}) 19065 if !ok { 19066 return fmt.Errorf("unexpected JSON type %v", value) 19067 } 19068 19069 var sv *types.VideoCodecSettings 19070 if *v == nil { 19071 sv = &types.VideoCodecSettings{} 19072 } else { 19073 sv = *v 19074 } 19075 19076 for key, value := range shape { 19077 switch key { 19078 case "av1Settings": 19079 if err := awsRestjson1_deserializeDocumentAv1Settings(&sv.Av1Settings, value); err != nil { 19080 return err 19081 } 19082 19083 case "avcIntraSettings": 19084 if err := awsRestjson1_deserializeDocumentAvcIntraSettings(&sv.AvcIntraSettings, value); err != nil { 19085 return err 19086 } 19087 19088 case "codec": 19089 if value != nil { 19090 jtv, ok := value.(string) 19091 if !ok { 19092 return fmt.Errorf("expected VideoCodec to be of type string, got %T instead", value) 19093 } 19094 sv.Codec = types.VideoCodec(jtv) 19095 } 19096 19097 case "frameCaptureSettings": 19098 if err := awsRestjson1_deserializeDocumentFrameCaptureSettings(&sv.FrameCaptureSettings, value); err != nil { 19099 return err 19100 } 19101 19102 case "h264Settings": 19103 if err := awsRestjson1_deserializeDocumentH264Settings(&sv.H264Settings, value); err != nil { 19104 return err 19105 } 19106 19107 case "h265Settings": 19108 if err := awsRestjson1_deserializeDocumentH265Settings(&sv.H265Settings, value); err != nil { 19109 return err 19110 } 19111 19112 case "mpeg2Settings": 19113 if err := awsRestjson1_deserializeDocumentMpeg2Settings(&sv.Mpeg2Settings, value); err != nil { 19114 return err 19115 } 19116 19117 case "proresSettings": 19118 if err := awsRestjson1_deserializeDocumentProresSettings(&sv.ProresSettings, value); err != nil { 19119 return err 19120 } 19121 19122 case "vc3Settings": 19123 if err := awsRestjson1_deserializeDocumentVc3Settings(&sv.Vc3Settings, value); err != nil { 19124 return err 19125 } 19126 19127 case "vp8Settings": 19128 if err := awsRestjson1_deserializeDocumentVp8Settings(&sv.Vp8Settings, value); err != nil { 19129 return err 19130 } 19131 19132 case "vp9Settings": 19133 if err := awsRestjson1_deserializeDocumentVp9Settings(&sv.Vp9Settings, value); err != nil { 19134 return err 19135 } 19136 19137 case "xavcSettings": 19138 if err := awsRestjson1_deserializeDocumentXavcSettings(&sv.XavcSettings, value); err != nil { 19139 return err 19140 } 19141 19142 default: 19143 _, _ = key, value 19144 19145 } 19146 } 19147 *v = sv 19148 return nil 19149} 19150 19151func awsRestjson1_deserializeDocumentVideoDescription(v **types.VideoDescription, value interface{}) error { 19152 if v == nil { 19153 return fmt.Errorf("unexpected nil of type %T", v) 19154 } 19155 if value == nil { 19156 return nil 19157 } 19158 19159 shape, ok := value.(map[string]interface{}) 19160 if !ok { 19161 return fmt.Errorf("unexpected JSON type %v", value) 19162 } 19163 19164 var sv *types.VideoDescription 19165 if *v == nil { 19166 sv = &types.VideoDescription{} 19167 } else { 19168 sv = *v 19169 } 19170 19171 for key, value := range shape { 19172 switch key { 19173 case "afdSignaling": 19174 if value != nil { 19175 jtv, ok := value.(string) 19176 if !ok { 19177 return fmt.Errorf("expected AfdSignaling to be of type string, got %T instead", value) 19178 } 19179 sv.AfdSignaling = types.AfdSignaling(jtv) 19180 } 19181 19182 case "antiAlias": 19183 if value != nil { 19184 jtv, ok := value.(string) 19185 if !ok { 19186 return fmt.Errorf("expected AntiAlias to be of type string, got %T instead", value) 19187 } 19188 sv.AntiAlias = types.AntiAlias(jtv) 19189 } 19190 19191 case "codecSettings": 19192 if err := awsRestjson1_deserializeDocumentVideoCodecSettings(&sv.CodecSettings, value); err != nil { 19193 return err 19194 } 19195 19196 case "colorMetadata": 19197 if value != nil { 19198 jtv, ok := value.(string) 19199 if !ok { 19200 return fmt.Errorf("expected ColorMetadata to be of type string, got %T instead", value) 19201 } 19202 sv.ColorMetadata = types.ColorMetadata(jtv) 19203 } 19204 19205 case "crop": 19206 if err := awsRestjson1_deserializeDocumentRectangle(&sv.Crop, value); err != nil { 19207 return err 19208 } 19209 19210 case "dropFrameTimecode": 19211 if value != nil { 19212 jtv, ok := value.(string) 19213 if !ok { 19214 return fmt.Errorf("expected DropFrameTimecode to be of type string, got %T instead", value) 19215 } 19216 sv.DropFrameTimecode = types.DropFrameTimecode(jtv) 19217 } 19218 19219 case "fixedAfd": 19220 if value != nil { 19221 jtv, ok := value.(json.Number) 19222 if !ok { 19223 return fmt.Errorf("expected __integerMin0Max15 to be json.Number, got %T instead", value) 19224 } 19225 i64, err := jtv.Int64() 19226 if err != nil { 19227 return err 19228 } 19229 sv.FixedAfd = int32(i64) 19230 } 19231 19232 case "height": 19233 if value != nil { 19234 jtv, ok := value.(json.Number) 19235 if !ok { 19236 return fmt.Errorf("expected __integerMin32Max8192 to be json.Number, got %T instead", value) 19237 } 19238 i64, err := jtv.Int64() 19239 if err != nil { 19240 return err 19241 } 19242 sv.Height = int32(i64) 19243 } 19244 19245 case "position": 19246 if err := awsRestjson1_deserializeDocumentRectangle(&sv.Position, value); err != nil { 19247 return err 19248 } 19249 19250 case "respondToAfd": 19251 if value != nil { 19252 jtv, ok := value.(string) 19253 if !ok { 19254 return fmt.Errorf("expected RespondToAfd to be of type string, got %T instead", value) 19255 } 19256 sv.RespondToAfd = types.RespondToAfd(jtv) 19257 } 19258 19259 case "scalingBehavior": 19260 if value != nil { 19261 jtv, ok := value.(string) 19262 if !ok { 19263 return fmt.Errorf("expected ScalingBehavior to be of type string, got %T instead", value) 19264 } 19265 sv.ScalingBehavior = types.ScalingBehavior(jtv) 19266 } 19267 19268 case "sharpness": 19269 if value != nil { 19270 jtv, ok := value.(json.Number) 19271 if !ok { 19272 return fmt.Errorf("expected __integerMin0Max100 to be json.Number, got %T instead", value) 19273 } 19274 i64, err := jtv.Int64() 19275 if err != nil { 19276 return err 19277 } 19278 sv.Sharpness = int32(i64) 19279 } 19280 19281 case "timecodeInsertion": 19282 if value != nil { 19283 jtv, ok := value.(string) 19284 if !ok { 19285 return fmt.Errorf("expected VideoTimecodeInsertion to be of type string, got %T instead", value) 19286 } 19287 sv.TimecodeInsertion = types.VideoTimecodeInsertion(jtv) 19288 } 19289 19290 case "videoPreprocessors": 19291 if err := awsRestjson1_deserializeDocumentVideoPreprocessor(&sv.VideoPreprocessors, value); err != nil { 19292 return err 19293 } 19294 19295 case "width": 19296 if value != nil { 19297 jtv, ok := value.(json.Number) 19298 if !ok { 19299 return fmt.Errorf("expected __integerMin32Max8192 to be json.Number, got %T instead", value) 19300 } 19301 i64, err := jtv.Int64() 19302 if err != nil { 19303 return err 19304 } 19305 sv.Width = int32(i64) 19306 } 19307 19308 default: 19309 _, _ = key, value 19310 19311 } 19312 } 19313 *v = sv 19314 return nil 19315} 19316 19317func awsRestjson1_deserializeDocumentVideoDetail(v **types.VideoDetail, value interface{}) error { 19318 if v == nil { 19319 return fmt.Errorf("unexpected nil of type %T", v) 19320 } 19321 if value == nil { 19322 return nil 19323 } 19324 19325 shape, ok := value.(map[string]interface{}) 19326 if !ok { 19327 return fmt.Errorf("unexpected JSON type %v", value) 19328 } 19329 19330 var sv *types.VideoDetail 19331 if *v == nil { 19332 sv = &types.VideoDetail{} 19333 } else { 19334 sv = *v 19335 } 19336 19337 for key, value := range shape { 19338 switch key { 19339 case "heightInPx": 19340 if value != nil { 19341 jtv, ok := value.(json.Number) 19342 if !ok { 19343 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 19344 } 19345 i64, err := jtv.Int64() 19346 if err != nil { 19347 return err 19348 } 19349 sv.HeightInPx = int32(i64) 19350 } 19351 19352 case "widthInPx": 19353 if value != nil { 19354 jtv, ok := value.(json.Number) 19355 if !ok { 19356 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 19357 } 19358 i64, err := jtv.Int64() 19359 if err != nil { 19360 return err 19361 } 19362 sv.WidthInPx = int32(i64) 19363 } 19364 19365 default: 19366 _, _ = key, value 19367 19368 } 19369 } 19370 *v = sv 19371 return nil 19372} 19373 19374func awsRestjson1_deserializeDocumentVideoPreprocessor(v **types.VideoPreprocessor, value interface{}) error { 19375 if v == nil { 19376 return fmt.Errorf("unexpected nil of type %T", v) 19377 } 19378 if value == nil { 19379 return nil 19380 } 19381 19382 shape, ok := value.(map[string]interface{}) 19383 if !ok { 19384 return fmt.Errorf("unexpected JSON type %v", value) 19385 } 19386 19387 var sv *types.VideoPreprocessor 19388 if *v == nil { 19389 sv = &types.VideoPreprocessor{} 19390 } else { 19391 sv = *v 19392 } 19393 19394 for key, value := range shape { 19395 switch key { 19396 case "colorCorrector": 19397 if err := awsRestjson1_deserializeDocumentColorCorrector(&sv.ColorCorrector, value); err != nil { 19398 return err 19399 } 19400 19401 case "deinterlacer": 19402 if err := awsRestjson1_deserializeDocumentDeinterlacer(&sv.Deinterlacer, value); err != nil { 19403 return err 19404 } 19405 19406 case "dolbyVision": 19407 if err := awsRestjson1_deserializeDocumentDolbyVision(&sv.DolbyVision, value); err != nil { 19408 return err 19409 } 19410 19411 case "hdr10Plus": 19412 if err := awsRestjson1_deserializeDocumentHdr10Plus(&sv.Hdr10Plus, value); err != nil { 19413 return err 19414 } 19415 19416 case "imageInserter": 19417 if err := awsRestjson1_deserializeDocumentImageInserter(&sv.ImageInserter, value); err != nil { 19418 return err 19419 } 19420 19421 case "noiseReducer": 19422 if err := awsRestjson1_deserializeDocumentNoiseReducer(&sv.NoiseReducer, value); err != nil { 19423 return err 19424 } 19425 19426 case "partnerWatermarking": 19427 if err := awsRestjson1_deserializeDocumentPartnerWatermarking(&sv.PartnerWatermarking, value); err != nil { 19428 return err 19429 } 19430 19431 case "timecodeBurnin": 19432 if err := awsRestjson1_deserializeDocumentTimecodeBurnin(&sv.TimecodeBurnin, value); err != nil { 19433 return err 19434 } 19435 19436 default: 19437 _, _ = key, value 19438 19439 } 19440 } 19441 *v = sv 19442 return nil 19443} 19444 19445func awsRestjson1_deserializeDocumentVideoSelector(v **types.VideoSelector, value interface{}) error { 19446 if v == nil { 19447 return fmt.Errorf("unexpected nil of type %T", v) 19448 } 19449 if value == nil { 19450 return nil 19451 } 19452 19453 shape, ok := value.(map[string]interface{}) 19454 if !ok { 19455 return fmt.Errorf("unexpected JSON type %v", value) 19456 } 19457 19458 var sv *types.VideoSelector 19459 if *v == nil { 19460 sv = &types.VideoSelector{} 19461 } else { 19462 sv = *v 19463 } 19464 19465 for key, value := range shape { 19466 switch key { 19467 case "alphaBehavior": 19468 if value != nil { 19469 jtv, ok := value.(string) 19470 if !ok { 19471 return fmt.Errorf("expected AlphaBehavior to be of type string, got %T instead", value) 19472 } 19473 sv.AlphaBehavior = types.AlphaBehavior(jtv) 19474 } 19475 19476 case "colorSpace": 19477 if value != nil { 19478 jtv, ok := value.(string) 19479 if !ok { 19480 return fmt.Errorf("expected ColorSpace to be of type string, got %T instead", value) 19481 } 19482 sv.ColorSpace = types.ColorSpace(jtv) 19483 } 19484 19485 case "colorSpaceUsage": 19486 if value != nil { 19487 jtv, ok := value.(string) 19488 if !ok { 19489 return fmt.Errorf("expected ColorSpaceUsage to be of type string, got %T instead", value) 19490 } 19491 sv.ColorSpaceUsage = types.ColorSpaceUsage(jtv) 19492 } 19493 19494 case "hdr10Metadata": 19495 if err := awsRestjson1_deserializeDocumentHdr10Metadata(&sv.Hdr10Metadata, value); err != nil { 19496 return err 19497 } 19498 19499 case "pid": 19500 if value != nil { 19501 jtv, ok := value.(json.Number) 19502 if !ok { 19503 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 19504 } 19505 i64, err := jtv.Int64() 19506 if err != nil { 19507 return err 19508 } 19509 sv.Pid = int32(i64) 19510 } 19511 19512 case "programNumber": 19513 if value != nil { 19514 jtv, ok := value.(json.Number) 19515 if !ok { 19516 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 19517 } 19518 i64, err := jtv.Int64() 19519 if err != nil { 19520 return err 19521 } 19522 sv.ProgramNumber = int32(i64) 19523 } 19524 19525 case "rotate": 19526 if value != nil { 19527 jtv, ok := value.(string) 19528 if !ok { 19529 return fmt.Errorf("expected InputRotate to be of type string, got %T instead", value) 19530 } 19531 sv.Rotate = types.InputRotate(jtv) 19532 } 19533 19534 case "sampleRange": 19535 if value != nil { 19536 jtv, ok := value.(string) 19537 if !ok { 19538 return fmt.Errorf("expected InputSampleRange to be of type string, got %T instead", value) 19539 } 19540 sv.SampleRange = types.InputSampleRange(jtv) 19541 } 19542 19543 default: 19544 _, _ = key, value 19545 19546 } 19547 } 19548 *v = sv 19549 return nil 19550} 19551 19552func awsRestjson1_deserializeDocumentVorbisSettings(v **types.VorbisSettings, value interface{}) error { 19553 if v == nil { 19554 return fmt.Errorf("unexpected nil of type %T", v) 19555 } 19556 if value == nil { 19557 return nil 19558 } 19559 19560 shape, ok := value.(map[string]interface{}) 19561 if !ok { 19562 return fmt.Errorf("unexpected JSON type %v", value) 19563 } 19564 19565 var sv *types.VorbisSettings 19566 if *v == nil { 19567 sv = &types.VorbisSettings{} 19568 } else { 19569 sv = *v 19570 } 19571 19572 for key, value := range shape { 19573 switch key { 19574 case "channels": 19575 if value != nil { 19576 jtv, ok := value.(json.Number) 19577 if !ok { 19578 return fmt.Errorf("expected __integerMin1Max2 to be json.Number, got %T instead", value) 19579 } 19580 i64, err := jtv.Int64() 19581 if err != nil { 19582 return err 19583 } 19584 sv.Channels = int32(i64) 19585 } 19586 19587 case "sampleRate": 19588 if value != nil { 19589 jtv, ok := value.(json.Number) 19590 if !ok { 19591 return fmt.Errorf("expected __integerMin22050Max48000 to be json.Number, got %T instead", value) 19592 } 19593 i64, err := jtv.Int64() 19594 if err != nil { 19595 return err 19596 } 19597 sv.SampleRate = int32(i64) 19598 } 19599 19600 case "vbrQuality": 19601 if value != nil { 19602 jtv, ok := value.(json.Number) 19603 if !ok { 19604 return fmt.Errorf("expected __integerMinNegative1Max10 to be json.Number, got %T instead", value) 19605 } 19606 i64, err := jtv.Int64() 19607 if err != nil { 19608 return err 19609 } 19610 sv.VbrQuality = int32(i64) 19611 } 19612 19613 default: 19614 _, _ = key, value 19615 19616 } 19617 } 19618 *v = sv 19619 return nil 19620} 19621 19622func awsRestjson1_deserializeDocumentVp8Settings(v **types.Vp8Settings, value interface{}) error { 19623 if v == nil { 19624 return fmt.Errorf("unexpected nil of type %T", v) 19625 } 19626 if value == nil { 19627 return nil 19628 } 19629 19630 shape, ok := value.(map[string]interface{}) 19631 if !ok { 19632 return fmt.Errorf("unexpected JSON type %v", value) 19633 } 19634 19635 var sv *types.Vp8Settings 19636 if *v == nil { 19637 sv = &types.Vp8Settings{} 19638 } else { 19639 sv = *v 19640 } 19641 19642 for key, value := range shape { 19643 switch key { 19644 case "bitrate": 19645 if value != nil { 19646 jtv, ok := value.(json.Number) 19647 if !ok { 19648 return fmt.Errorf("expected __integerMin1000Max1152000000 to be json.Number, got %T instead", value) 19649 } 19650 i64, err := jtv.Int64() 19651 if err != nil { 19652 return err 19653 } 19654 sv.Bitrate = int32(i64) 19655 } 19656 19657 case "framerateControl": 19658 if value != nil { 19659 jtv, ok := value.(string) 19660 if !ok { 19661 return fmt.Errorf("expected Vp8FramerateControl to be of type string, got %T instead", value) 19662 } 19663 sv.FramerateControl = types.Vp8FramerateControl(jtv) 19664 } 19665 19666 case "framerateConversionAlgorithm": 19667 if value != nil { 19668 jtv, ok := value.(string) 19669 if !ok { 19670 return fmt.Errorf("expected Vp8FramerateConversionAlgorithm to be of type string, got %T instead", value) 19671 } 19672 sv.FramerateConversionAlgorithm = types.Vp8FramerateConversionAlgorithm(jtv) 19673 } 19674 19675 case "framerateDenominator": 19676 if value != nil { 19677 jtv, ok := value.(json.Number) 19678 if !ok { 19679 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 19680 } 19681 i64, err := jtv.Int64() 19682 if err != nil { 19683 return err 19684 } 19685 sv.FramerateDenominator = int32(i64) 19686 } 19687 19688 case "framerateNumerator": 19689 if value != nil { 19690 jtv, ok := value.(json.Number) 19691 if !ok { 19692 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 19693 } 19694 i64, err := jtv.Int64() 19695 if err != nil { 19696 return err 19697 } 19698 sv.FramerateNumerator = int32(i64) 19699 } 19700 19701 case "gopSize": 19702 if value != nil { 19703 switch jtv := value.(type) { 19704 case json.Number: 19705 f64, err := jtv.Float64() 19706 if err != nil { 19707 return err 19708 } 19709 sv.GopSize = f64 19710 19711 case string: 19712 var f64 float64 19713 switch { 19714 case strings.EqualFold(jtv, "NaN"): 19715 f64 = math.NaN() 19716 19717 case strings.EqualFold(jtv, "Infinity"): 19718 f64 = math.Inf(1) 19719 19720 case strings.EqualFold(jtv, "-Infinity"): 19721 f64 = math.Inf(-1) 19722 19723 default: 19724 return fmt.Errorf("unknown JSON number value: %s", jtv) 19725 19726 } 19727 sv.GopSize = f64 19728 19729 default: 19730 return fmt.Errorf("expected __doubleMin0 to be a JSON Number, got %T instead", value) 19731 19732 } 19733 } 19734 19735 case "hrdBufferSize": 19736 if value != nil { 19737 jtv, ok := value.(json.Number) 19738 if !ok { 19739 return fmt.Errorf("expected __integerMin0Max47185920 to be json.Number, got %T instead", value) 19740 } 19741 i64, err := jtv.Int64() 19742 if err != nil { 19743 return err 19744 } 19745 sv.HrdBufferSize = int32(i64) 19746 } 19747 19748 case "maxBitrate": 19749 if value != nil { 19750 jtv, ok := value.(json.Number) 19751 if !ok { 19752 return fmt.Errorf("expected __integerMin1000Max1152000000 to be json.Number, got %T instead", value) 19753 } 19754 i64, err := jtv.Int64() 19755 if err != nil { 19756 return err 19757 } 19758 sv.MaxBitrate = int32(i64) 19759 } 19760 19761 case "parControl": 19762 if value != nil { 19763 jtv, ok := value.(string) 19764 if !ok { 19765 return fmt.Errorf("expected Vp8ParControl to be of type string, got %T instead", value) 19766 } 19767 sv.ParControl = types.Vp8ParControl(jtv) 19768 } 19769 19770 case "parDenominator": 19771 if value != nil { 19772 jtv, ok := value.(json.Number) 19773 if !ok { 19774 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 19775 } 19776 i64, err := jtv.Int64() 19777 if err != nil { 19778 return err 19779 } 19780 sv.ParDenominator = int32(i64) 19781 } 19782 19783 case "parNumerator": 19784 if value != nil { 19785 jtv, ok := value.(json.Number) 19786 if !ok { 19787 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 19788 } 19789 i64, err := jtv.Int64() 19790 if err != nil { 19791 return err 19792 } 19793 sv.ParNumerator = int32(i64) 19794 } 19795 19796 case "qualityTuningLevel": 19797 if value != nil { 19798 jtv, ok := value.(string) 19799 if !ok { 19800 return fmt.Errorf("expected Vp8QualityTuningLevel to be of type string, got %T instead", value) 19801 } 19802 sv.QualityTuningLevel = types.Vp8QualityTuningLevel(jtv) 19803 } 19804 19805 case "rateControlMode": 19806 if value != nil { 19807 jtv, ok := value.(string) 19808 if !ok { 19809 return fmt.Errorf("expected Vp8RateControlMode to be of type string, got %T instead", value) 19810 } 19811 sv.RateControlMode = types.Vp8RateControlMode(jtv) 19812 } 19813 19814 default: 19815 _, _ = key, value 19816 19817 } 19818 } 19819 *v = sv 19820 return nil 19821} 19822 19823func awsRestjson1_deserializeDocumentVp9Settings(v **types.Vp9Settings, value interface{}) error { 19824 if v == nil { 19825 return fmt.Errorf("unexpected nil of type %T", v) 19826 } 19827 if value == nil { 19828 return nil 19829 } 19830 19831 shape, ok := value.(map[string]interface{}) 19832 if !ok { 19833 return fmt.Errorf("unexpected JSON type %v", value) 19834 } 19835 19836 var sv *types.Vp9Settings 19837 if *v == nil { 19838 sv = &types.Vp9Settings{} 19839 } else { 19840 sv = *v 19841 } 19842 19843 for key, value := range shape { 19844 switch key { 19845 case "bitrate": 19846 if value != nil { 19847 jtv, ok := value.(json.Number) 19848 if !ok { 19849 return fmt.Errorf("expected __integerMin1000Max480000000 to be json.Number, got %T instead", value) 19850 } 19851 i64, err := jtv.Int64() 19852 if err != nil { 19853 return err 19854 } 19855 sv.Bitrate = int32(i64) 19856 } 19857 19858 case "framerateControl": 19859 if value != nil { 19860 jtv, ok := value.(string) 19861 if !ok { 19862 return fmt.Errorf("expected Vp9FramerateControl to be of type string, got %T instead", value) 19863 } 19864 sv.FramerateControl = types.Vp9FramerateControl(jtv) 19865 } 19866 19867 case "framerateConversionAlgorithm": 19868 if value != nil { 19869 jtv, ok := value.(string) 19870 if !ok { 19871 return fmt.Errorf("expected Vp9FramerateConversionAlgorithm to be of type string, got %T instead", value) 19872 } 19873 sv.FramerateConversionAlgorithm = types.Vp9FramerateConversionAlgorithm(jtv) 19874 } 19875 19876 case "framerateDenominator": 19877 if value != nil { 19878 jtv, ok := value.(json.Number) 19879 if !ok { 19880 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 19881 } 19882 i64, err := jtv.Int64() 19883 if err != nil { 19884 return err 19885 } 19886 sv.FramerateDenominator = int32(i64) 19887 } 19888 19889 case "framerateNumerator": 19890 if value != nil { 19891 jtv, ok := value.(json.Number) 19892 if !ok { 19893 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 19894 } 19895 i64, err := jtv.Int64() 19896 if err != nil { 19897 return err 19898 } 19899 sv.FramerateNumerator = int32(i64) 19900 } 19901 19902 case "gopSize": 19903 if value != nil { 19904 switch jtv := value.(type) { 19905 case json.Number: 19906 f64, err := jtv.Float64() 19907 if err != nil { 19908 return err 19909 } 19910 sv.GopSize = f64 19911 19912 case string: 19913 var f64 float64 19914 switch { 19915 case strings.EqualFold(jtv, "NaN"): 19916 f64 = math.NaN() 19917 19918 case strings.EqualFold(jtv, "Infinity"): 19919 f64 = math.Inf(1) 19920 19921 case strings.EqualFold(jtv, "-Infinity"): 19922 f64 = math.Inf(-1) 19923 19924 default: 19925 return fmt.Errorf("unknown JSON number value: %s", jtv) 19926 19927 } 19928 sv.GopSize = f64 19929 19930 default: 19931 return fmt.Errorf("expected __doubleMin0 to be a JSON Number, got %T instead", value) 19932 19933 } 19934 } 19935 19936 case "hrdBufferSize": 19937 if value != nil { 19938 jtv, ok := value.(json.Number) 19939 if !ok { 19940 return fmt.Errorf("expected __integerMin0Max47185920 to be json.Number, got %T instead", value) 19941 } 19942 i64, err := jtv.Int64() 19943 if err != nil { 19944 return err 19945 } 19946 sv.HrdBufferSize = int32(i64) 19947 } 19948 19949 case "maxBitrate": 19950 if value != nil { 19951 jtv, ok := value.(json.Number) 19952 if !ok { 19953 return fmt.Errorf("expected __integerMin1000Max480000000 to be json.Number, got %T instead", value) 19954 } 19955 i64, err := jtv.Int64() 19956 if err != nil { 19957 return err 19958 } 19959 sv.MaxBitrate = int32(i64) 19960 } 19961 19962 case "parControl": 19963 if value != nil { 19964 jtv, ok := value.(string) 19965 if !ok { 19966 return fmt.Errorf("expected Vp9ParControl to be of type string, got %T instead", value) 19967 } 19968 sv.ParControl = types.Vp9ParControl(jtv) 19969 } 19970 19971 case "parDenominator": 19972 if value != nil { 19973 jtv, ok := value.(json.Number) 19974 if !ok { 19975 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 19976 } 19977 i64, err := jtv.Int64() 19978 if err != nil { 19979 return err 19980 } 19981 sv.ParDenominator = int32(i64) 19982 } 19983 19984 case "parNumerator": 19985 if value != nil { 19986 jtv, ok := value.(json.Number) 19987 if !ok { 19988 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 19989 } 19990 i64, err := jtv.Int64() 19991 if err != nil { 19992 return err 19993 } 19994 sv.ParNumerator = int32(i64) 19995 } 19996 19997 case "qualityTuningLevel": 19998 if value != nil { 19999 jtv, ok := value.(string) 20000 if !ok { 20001 return fmt.Errorf("expected Vp9QualityTuningLevel to be of type string, got %T instead", value) 20002 } 20003 sv.QualityTuningLevel = types.Vp9QualityTuningLevel(jtv) 20004 } 20005 20006 case "rateControlMode": 20007 if value != nil { 20008 jtv, ok := value.(string) 20009 if !ok { 20010 return fmt.Errorf("expected Vp9RateControlMode to be of type string, got %T instead", value) 20011 } 20012 sv.RateControlMode = types.Vp9RateControlMode(jtv) 20013 } 20014 20015 default: 20016 _, _ = key, value 20017 20018 } 20019 } 20020 *v = sv 20021 return nil 20022} 20023 20024func awsRestjson1_deserializeDocumentWavSettings(v **types.WavSettings, value interface{}) error { 20025 if v == nil { 20026 return fmt.Errorf("unexpected nil of type %T", v) 20027 } 20028 if value == nil { 20029 return nil 20030 } 20031 20032 shape, ok := value.(map[string]interface{}) 20033 if !ok { 20034 return fmt.Errorf("unexpected JSON type %v", value) 20035 } 20036 20037 var sv *types.WavSettings 20038 if *v == nil { 20039 sv = &types.WavSettings{} 20040 } else { 20041 sv = *v 20042 } 20043 20044 for key, value := range shape { 20045 switch key { 20046 case "bitDepth": 20047 if value != nil { 20048 jtv, ok := value.(json.Number) 20049 if !ok { 20050 return fmt.Errorf("expected __integerMin16Max24 to be json.Number, got %T instead", value) 20051 } 20052 i64, err := jtv.Int64() 20053 if err != nil { 20054 return err 20055 } 20056 sv.BitDepth = int32(i64) 20057 } 20058 20059 case "channels": 20060 if value != nil { 20061 jtv, ok := value.(json.Number) 20062 if !ok { 20063 return fmt.Errorf("expected __integerMin1Max64 to be json.Number, got %T instead", value) 20064 } 20065 i64, err := jtv.Int64() 20066 if err != nil { 20067 return err 20068 } 20069 sv.Channels = int32(i64) 20070 } 20071 20072 case "format": 20073 if value != nil { 20074 jtv, ok := value.(string) 20075 if !ok { 20076 return fmt.Errorf("expected WavFormat to be of type string, got %T instead", value) 20077 } 20078 sv.Format = types.WavFormat(jtv) 20079 } 20080 20081 case "sampleRate": 20082 if value != nil { 20083 jtv, ok := value.(json.Number) 20084 if !ok { 20085 return fmt.Errorf("expected __integerMin8000Max192000 to be json.Number, got %T instead", value) 20086 } 20087 i64, err := jtv.Int64() 20088 if err != nil { 20089 return err 20090 } 20091 sv.SampleRate = int32(i64) 20092 } 20093 20094 default: 20095 _, _ = key, value 20096 20097 } 20098 } 20099 *v = sv 20100 return nil 20101} 20102 20103func awsRestjson1_deserializeDocumentWebvttDestinationSettings(v **types.WebvttDestinationSettings, value interface{}) error { 20104 if v == nil { 20105 return fmt.Errorf("unexpected nil of type %T", v) 20106 } 20107 if value == nil { 20108 return nil 20109 } 20110 20111 shape, ok := value.(map[string]interface{}) 20112 if !ok { 20113 return fmt.Errorf("unexpected JSON type %v", value) 20114 } 20115 20116 var sv *types.WebvttDestinationSettings 20117 if *v == nil { 20118 sv = &types.WebvttDestinationSettings{} 20119 } else { 20120 sv = *v 20121 } 20122 20123 for key, value := range shape { 20124 switch key { 20125 case "stylePassthrough": 20126 if value != nil { 20127 jtv, ok := value.(string) 20128 if !ok { 20129 return fmt.Errorf("expected WebvttStylePassthrough to be of type string, got %T instead", value) 20130 } 20131 sv.StylePassthrough = types.WebvttStylePassthrough(jtv) 20132 } 20133 20134 default: 20135 _, _ = key, value 20136 20137 } 20138 } 20139 *v = sv 20140 return nil 20141} 20142 20143func awsRestjson1_deserializeDocumentWebvttHlsSourceSettings(v **types.WebvttHlsSourceSettings, value interface{}) error { 20144 if v == nil { 20145 return fmt.Errorf("unexpected nil of type %T", v) 20146 } 20147 if value == nil { 20148 return nil 20149 } 20150 20151 shape, ok := value.(map[string]interface{}) 20152 if !ok { 20153 return fmt.Errorf("unexpected JSON type %v", value) 20154 } 20155 20156 var sv *types.WebvttHlsSourceSettings 20157 if *v == nil { 20158 sv = &types.WebvttHlsSourceSettings{} 20159 } else { 20160 sv = *v 20161 } 20162 20163 for key, value := range shape { 20164 switch key { 20165 case "renditionGroupId": 20166 if value != nil { 20167 jtv, ok := value.(string) 20168 if !ok { 20169 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 20170 } 20171 sv.RenditionGroupId = ptr.String(jtv) 20172 } 20173 20174 case "renditionLanguageCode": 20175 if value != nil { 20176 jtv, ok := value.(string) 20177 if !ok { 20178 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 20179 } 20180 sv.RenditionLanguageCode = types.LanguageCode(jtv) 20181 } 20182 20183 case "renditionName": 20184 if value != nil { 20185 jtv, ok := value.(string) 20186 if !ok { 20187 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 20188 } 20189 sv.RenditionName = ptr.String(jtv) 20190 } 20191 20192 default: 20193 _, _ = key, value 20194 20195 } 20196 } 20197 *v = sv 20198 return nil 20199} 20200 20201func awsRestjson1_deserializeDocumentXavc4kIntraCbgProfileSettings(v **types.Xavc4kIntraCbgProfileSettings, value interface{}) error { 20202 if v == nil { 20203 return fmt.Errorf("unexpected nil of type %T", v) 20204 } 20205 if value == nil { 20206 return nil 20207 } 20208 20209 shape, ok := value.(map[string]interface{}) 20210 if !ok { 20211 return fmt.Errorf("unexpected JSON type %v", value) 20212 } 20213 20214 var sv *types.Xavc4kIntraCbgProfileSettings 20215 if *v == nil { 20216 sv = &types.Xavc4kIntraCbgProfileSettings{} 20217 } else { 20218 sv = *v 20219 } 20220 20221 for key, value := range shape { 20222 switch key { 20223 case "xavcClass": 20224 if value != nil { 20225 jtv, ok := value.(string) 20226 if !ok { 20227 return fmt.Errorf("expected Xavc4kIntraCbgProfileClass to be of type string, got %T instead", value) 20228 } 20229 sv.XavcClass = types.Xavc4kIntraCbgProfileClass(jtv) 20230 } 20231 20232 default: 20233 _, _ = key, value 20234 20235 } 20236 } 20237 *v = sv 20238 return nil 20239} 20240 20241func awsRestjson1_deserializeDocumentXavc4kIntraVbrProfileSettings(v **types.Xavc4kIntraVbrProfileSettings, value interface{}) error { 20242 if v == nil { 20243 return fmt.Errorf("unexpected nil of type %T", v) 20244 } 20245 if value == nil { 20246 return nil 20247 } 20248 20249 shape, ok := value.(map[string]interface{}) 20250 if !ok { 20251 return fmt.Errorf("unexpected JSON type %v", value) 20252 } 20253 20254 var sv *types.Xavc4kIntraVbrProfileSettings 20255 if *v == nil { 20256 sv = &types.Xavc4kIntraVbrProfileSettings{} 20257 } else { 20258 sv = *v 20259 } 20260 20261 for key, value := range shape { 20262 switch key { 20263 case "xavcClass": 20264 if value != nil { 20265 jtv, ok := value.(string) 20266 if !ok { 20267 return fmt.Errorf("expected Xavc4kIntraVbrProfileClass to be of type string, got %T instead", value) 20268 } 20269 sv.XavcClass = types.Xavc4kIntraVbrProfileClass(jtv) 20270 } 20271 20272 default: 20273 _, _ = key, value 20274 20275 } 20276 } 20277 *v = sv 20278 return nil 20279} 20280 20281func awsRestjson1_deserializeDocumentXavc4kProfileSettings(v **types.Xavc4kProfileSettings, value interface{}) error { 20282 if v == nil { 20283 return fmt.Errorf("unexpected nil of type %T", v) 20284 } 20285 if value == nil { 20286 return nil 20287 } 20288 20289 shape, ok := value.(map[string]interface{}) 20290 if !ok { 20291 return fmt.Errorf("unexpected JSON type %v", value) 20292 } 20293 20294 var sv *types.Xavc4kProfileSettings 20295 if *v == nil { 20296 sv = &types.Xavc4kProfileSettings{} 20297 } else { 20298 sv = *v 20299 } 20300 20301 for key, value := range shape { 20302 switch key { 20303 case "bitrateClass": 20304 if value != nil { 20305 jtv, ok := value.(string) 20306 if !ok { 20307 return fmt.Errorf("expected Xavc4kProfileBitrateClass to be of type string, got %T instead", value) 20308 } 20309 sv.BitrateClass = types.Xavc4kProfileBitrateClass(jtv) 20310 } 20311 20312 case "codecProfile": 20313 if value != nil { 20314 jtv, ok := value.(string) 20315 if !ok { 20316 return fmt.Errorf("expected Xavc4kProfileCodecProfile to be of type string, got %T instead", value) 20317 } 20318 sv.CodecProfile = types.Xavc4kProfileCodecProfile(jtv) 20319 } 20320 20321 case "flickerAdaptiveQuantization": 20322 if value != nil { 20323 jtv, ok := value.(string) 20324 if !ok { 20325 return fmt.Errorf("expected XavcFlickerAdaptiveQuantization to be of type string, got %T instead", value) 20326 } 20327 sv.FlickerAdaptiveQuantization = types.XavcFlickerAdaptiveQuantization(jtv) 20328 } 20329 20330 case "gopBReference": 20331 if value != nil { 20332 jtv, ok := value.(string) 20333 if !ok { 20334 return fmt.Errorf("expected XavcGopBReference to be of type string, got %T instead", value) 20335 } 20336 sv.GopBReference = types.XavcGopBReference(jtv) 20337 } 20338 20339 case "gopClosedCadence": 20340 if value != nil { 20341 jtv, ok := value.(json.Number) 20342 if !ok { 20343 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 20344 } 20345 i64, err := jtv.Int64() 20346 if err != nil { 20347 return err 20348 } 20349 sv.GopClosedCadence = int32(i64) 20350 } 20351 20352 case "hrdBufferSize": 20353 if value != nil { 20354 jtv, ok := value.(json.Number) 20355 if !ok { 20356 return fmt.Errorf("expected __integerMin0Max1152000000 to be json.Number, got %T instead", value) 20357 } 20358 i64, err := jtv.Int64() 20359 if err != nil { 20360 return err 20361 } 20362 sv.HrdBufferSize = int32(i64) 20363 } 20364 20365 case "qualityTuningLevel": 20366 if value != nil { 20367 jtv, ok := value.(string) 20368 if !ok { 20369 return fmt.Errorf("expected Xavc4kProfileQualityTuningLevel to be of type string, got %T instead", value) 20370 } 20371 sv.QualityTuningLevel = types.Xavc4kProfileQualityTuningLevel(jtv) 20372 } 20373 20374 case "slices": 20375 if value != nil { 20376 jtv, ok := value.(json.Number) 20377 if !ok { 20378 return fmt.Errorf("expected __integerMin8Max12 to be json.Number, got %T instead", value) 20379 } 20380 i64, err := jtv.Int64() 20381 if err != nil { 20382 return err 20383 } 20384 sv.Slices = int32(i64) 20385 } 20386 20387 default: 20388 _, _ = key, value 20389 20390 } 20391 } 20392 *v = sv 20393 return nil 20394} 20395 20396func awsRestjson1_deserializeDocumentXavcHdIntraCbgProfileSettings(v **types.XavcHdIntraCbgProfileSettings, value interface{}) error { 20397 if v == nil { 20398 return fmt.Errorf("unexpected nil of type %T", v) 20399 } 20400 if value == nil { 20401 return nil 20402 } 20403 20404 shape, ok := value.(map[string]interface{}) 20405 if !ok { 20406 return fmt.Errorf("unexpected JSON type %v", value) 20407 } 20408 20409 var sv *types.XavcHdIntraCbgProfileSettings 20410 if *v == nil { 20411 sv = &types.XavcHdIntraCbgProfileSettings{} 20412 } else { 20413 sv = *v 20414 } 20415 20416 for key, value := range shape { 20417 switch key { 20418 case "xavcClass": 20419 if value != nil { 20420 jtv, ok := value.(string) 20421 if !ok { 20422 return fmt.Errorf("expected XavcHdIntraCbgProfileClass to be of type string, got %T instead", value) 20423 } 20424 sv.XavcClass = types.XavcHdIntraCbgProfileClass(jtv) 20425 } 20426 20427 default: 20428 _, _ = key, value 20429 20430 } 20431 } 20432 *v = sv 20433 return nil 20434} 20435 20436func awsRestjson1_deserializeDocumentXavcHdProfileSettings(v **types.XavcHdProfileSettings, value interface{}) error { 20437 if v == nil { 20438 return fmt.Errorf("unexpected nil of type %T", v) 20439 } 20440 if value == nil { 20441 return nil 20442 } 20443 20444 shape, ok := value.(map[string]interface{}) 20445 if !ok { 20446 return fmt.Errorf("unexpected JSON type %v", value) 20447 } 20448 20449 var sv *types.XavcHdProfileSettings 20450 if *v == nil { 20451 sv = &types.XavcHdProfileSettings{} 20452 } else { 20453 sv = *v 20454 } 20455 20456 for key, value := range shape { 20457 switch key { 20458 case "bitrateClass": 20459 if value != nil { 20460 jtv, ok := value.(string) 20461 if !ok { 20462 return fmt.Errorf("expected XavcHdProfileBitrateClass to be of type string, got %T instead", value) 20463 } 20464 sv.BitrateClass = types.XavcHdProfileBitrateClass(jtv) 20465 } 20466 20467 case "flickerAdaptiveQuantization": 20468 if value != nil { 20469 jtv, ok := value.(string) 20470 if !ok { 20471 return fmt.Errorf("expected XavcFlickerAdaptiveQuantization to be of type string, got %T instead", value) 20472 } 20473 sv.FlickerAdaptiveQuantization = types.XavcFlickerAdaptiveQuantization(jtv) 20474 } 20475 20476 case "gopBReference": 20477 if value != nil { 20478 jtv, ok := value.(string) 20479 if !ok { 20480 return fmt.Errorf("expected XavcGopBReference to be of type string, got %T instead", value) 20481 } 20482 sv.GopBReference = types.XavcGopBReference(jtv) 20483 } 20484 20485 case "gopClosedCadence": 20486 if value != nil { 20487 jtv, ok := value.(json.Number) 20488 if !ok { 20489 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 20490 } 20491 i64, err := jtv.Int64() 20492 if err != nil { 20493 return err 20494 } 20495 sv.GopClosedCadence = int32(i64) 20496 } 20497 20498 case "hrdBufferSize": 20499 if value != nil { 20500 jtv, ok := value.(json.Number) 20501 if !ok { 20502 return fmt.Errorf("expected __integerMin0Max1152000000 to be json.Number, got %T instead", value) 20503 } 20504 i64, err := jtv.Int64() 20505 if err != nil { 20506 return err 20507 } 20508 sv.HrdBufferSize = int32(i64) 20509 } 20510 20511 case "interlaceMode": 20512 if value != nil { 20513 jtv, ok := value.(string) 20514 if !ok { 20515 return fmt.Errorf("expected XavcInterlaceMode to be of type string, got %T instead", value) 20516 } 20517 sv.InterlaceMode = types.XavcInterlaceMode(jtv) 20518 } 20519 20520 case "qualityTuningLevel": 20521 if value != nil { 20522 jtv, ok := value.(string) 20523 if !ok { 20524 return fmt.Errorf("expected XavcHdProfileQualityTuningLevel to be of type string, got %T instead", value) 20525 } 20526 sv.QualityTuningLevel = types.XavcHdProfileQualityTuningLevel(jtv) 20527 } 20528 20529 case "slices": 20530 if value != nil { 20531 jtv, ok := value.(json.Number) 20532 if !ok { 20533 return fmt.Errorf("expected __integerMin4Max12 to be json.Number, got %T instead", value) 20534 } 20535 i64, err := jtv.Int64() 20536 if err != nil { 20537 return err 20538 } 20539 sv.Slices = int32(i64) 20540 } 20541 20542 case "telecine": 20543 if value != nil { 20544 jtv, ok := value.(string) 20545 if !ok { 20546 return fmt.Errorf("expected XavcHdProfileTelecine to be of type string, got %T instead", value) 20547 } 20548 sv.Telecine = types.XavcHdProfileTelecine(jtv) 20549 } 20550 20551 default: 20552 _, _ = key, value 20553 20554 } 20555 } 20556 *v = sv 20557 return nil 20558} 20559 20560func awsRestjson1_deserializeDocumentXavcSettings(v **types.XavcSettings, value interface{}) error { 20561 if v == nil { 20562 return fmt.Errorf("unexpected nil of type %T", v) 20563 } 20564 if value == nil { 20565 return nil 20566 } 20567 20568 shape, ok := value.(map[string]interface{}) 20569 if !ok { 20570 return fmt.Errorf("unexpected JSON type %v", value) 20571 } 20572 20573 var sv *types.XavcSettings 20574 if *v == nil { 20575 sv = &types.XavcSettings{} 20576 } else { 20577 sv = *v 20578 } 20579 20580 for key, value := range shape { 20581 switch key { 20582 case "adaptiveQuantization": 20583 if value != nil { 20584 jtv, ok := value.(string) 20585 if !ok { 20586 return fmt.Errorf("expected XavcAdaptiveQuantization to be of type string, got %T instead", value) 20587 } 20588 sv.AdaptiveQuantization = types.XavcAdaptiveQuantization(jtv) 20589 } 20590 20591 case "entropyEncoding": 20592 if value != nil { 20593 jtv, ok := value.(string) 20594 if !ok { 20595 return fmt.Errorf("expected XavcEntropyEncoding to be of type string, got %T instead", value) 20596 } 20597 sv.EntropyEncoding = types.XavcEntropyEncoding(jtv) 20598 } 20599 20600 case "framerateControl": 20601 if value != nil { 20602 jtv, ok := value.(string) 20603 if !ok { 20604 return fmt.Errorf("expected XavcFramerateControl to be of type string, got %T instead", value) 20605 } 20606 sv.FramerateControl = types.XavcFramerateControl(jtv) 20607 } 20608 20609 case "framerateConversionAlgorithm": 20610 if value != nil { 20611 jtv, ok := value.(string) 20612 if !ok { 20613 return fmt.Errorf("expected XavcFramerateConversionAlgorithm to be of type string, got %T instead", value) 20614 } 20615 sv.FramerateConversionAlgorithm = types.XavcFramerateConversionAlgorithm(jtv) 20616 } 20617 20618 case "framerateDenominator": 20619 if value != nil { 20620 jtv, ok := value.(json.Number) 20621 if !ok { 20622 return fmt.Errorf("expected __integerMin1Max1001 to be json.Number, got %T instead", value) 20623 } 20624 i64, err := jtv.Int64() 20625 if err != nil { 20626 return err 20627 } 20628 sv.FramerateDenominator = int32(i64) 20629 } 20630 20631 case "framerateNumerator": 20632 if value != nil { 20633 jtv, ok := value.(json.Number) 20634 if !ok { 20635 return fmt.Errorf("expected __integerMin24Max60000 to be json.Number, got %T instead", value) 20636 } 20637 i64, err := jtv.Int64() 20638 if err != nil { 20639 return err 20640 } 20641 sv.FramerateNumerator = int32(i64) 20642 } 20643 20644 case "profile": 20645 if value != nil { 20646 jtv, ok := value.(string) 20647 if !ok { 20648 return fmt.Errorf("expected XavcProfile to be of type string, got %T instead", value) 20649 } 20650 sv.Profile = types.XavcProfile(jtv) 20651 } 20652 20653 case "slowPal": 20654 if value != nil { 20655 jtv, ok := value.(string) 20656 if !ok { 20657 return fmt.Errorf("expected XavcSlowPal to be of type string, got %T instead", value) 20658 } 20659 sv.SlowPal = types.XavcSlowPal(jtv) 20660 } 20661 20662 case "softness": 20663 if value != nil { 20664 jtv, ok := value.(json.Number) 20665 if !ok { 20666 return fmt.Errorf("expected __integerMin0Max128 to be json.Number, got %T instead", value) 20667 } 20668 i64, err := jtv.Int64() 20669 if err != nil { 20670 return err 20671 } 20672 sv.Softness = int32(i64) 20673 } 20674 20675 case "spatialAdaptiveQuantization": 20676 if value != nil { 20677 jtv, ok := value.(string) 20678 if !ok { 20679 return fmt.Errorf("expected XavcSpatialAdaptiveQuantization to be of type string, got %T instead", value) 20680 } 20681 sv.SpatialAdaptiveQuantization = types.XavcSpatialAdaptiveQuantization(jtv) 20682 } 20683 20684 case "temporalAdaptiveQuantization": 20685 if value != nil { 20686 jtv, ok := value.(string) 20687 if !ok { 20688 return fmt.Errorf("expected XavcTemporalAdaptiveQuantization to be of type string, got %T instead", value) 20689 } 20690 sv.TemporalAdaptiveQuantization = types.XavcTemporalAdaptiveQuantization(jtv) 20691 } 20692 20693 case "xavc4kIntraCbgProfileSettings": 20694 if err := awsRestjson1_deserializeDocumentXavc4kIntraCbgProfileSettings(&sv.Xavc4kIntraCbgProfileSettings, value); err != nil { 20695 return err 20696 } 20697 20698 case "xavc4kIntraVbrProfileSettings": 20699 if err := awsRestjson1_deserializeDocumentXavc4kIntraVbrProfileSettings(&sv.Xavc4kIntraVbrProfileSettings, value); err != nil { 20700 return err 20701 } 20702 20703 case "xavc4kProfileSettings": 20704 if err := awsRestjson1_deserializeDocumentXavc4kProfileSettings(&sv.Xavc4kProfileSettings, value); err != nil { 20705 return err 20706 } 20707 20708 case "xavcHdIntraCbgProfileSettings": 20709 if err := awsRestjson1_deserializeDocumentXavcHdIntraCbgProfileSettings(&sv.XavcHdIntraCbgProfileSettings, value); err != nil { 20710 return err 20711 } 20712 20713 case "xavcHdProfileSettings": 20714 if err := awsRestjson1_deserializeDocumentXavcHdProfileSettings(&sv.XavcHdProfileSettings, value); err != nil { 20715 return err 20716 } 20717 20718 default: 20719 _, _ = key, value 20720 20721 } 20722 } 20723 *v = sv 20724 return nil 20725} 20726