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 "strings" 20) 21 22type awsRestjson1_deserializeOpAssociateCertificate struct { 23} 24 25func (*awsRestjson1_deserializeOpAssociateCertificate) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsRestjson1_deserializeOpAssociateCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 30 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 31) { 32 out, metadata, err = next.HandleDeserialize(ctx, in) 33 if err != nil { 34 return out, metadata, err 35 } 36 37 response, ok := out.RawResponse.(*smithyhttp.Response) 38 if !ok { 39 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 40 } 41 42 if response.StatusCode < 200 || response.StatusCode >= 300 { 43 return out, metadata, awsRestjson1_deserializeOpErrorAssociateCertificate(response, &metadata) 44 } 45 output := &AssociateCertificateOutput{} 46 out.Result = output 47 48 return out, metadata, err 49} 50 51func awsRestjson1_deserializeOpErrorAssociateCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 52 var errorBuffer bytes.Buffer 53 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 54 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 55 } 56 errorBody := bytes.NewReader(errorBuffer.Bytes()) 57 58 errorCode := "UnknownError" 59 errorMessage := errorCode 60 61 code := response.Header.Get("X-Amzn-ErrorType") 62 if len(code) != 0 { 63 errorCode = restjson.SanitizeErrorCode(code) 64 } 65 66 var buff [1024]byte 67 ringBuffer := smithyio.NewRingBuffer(buff[:]) 68 69 body := io.TeeReader(errorBody, ringBuffer) 70 decoder := json.NewDecoder(body) 71 decoder.UseNumber() 72 code, message, err := restjson.GetErrorInfo(decoder) 73 if err != nil { 74 var snapshot bytes.Buffer 75 io.Copy(&snapshot, ringBuffer) 76 err = &smithy.DeserializationError{ 77 Err: fmt.Errorf("failed to decode response body, %w", err), 78 Snapshot: snapshot.Bytes(), 79 } 80 return err 81 } 82 83 errorBody.Seek(0, io.SeekStart) 84 if len(code) != 0 { 85 errorCode = restjson.SanitizeErrorCode(code) 86 } 87 if len(message) != 0 { 88 errorMessage = message 89 } 90 91 switch { 92 case strings.EqualFold("BadRequestException", errorCode): 93 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 94 95 case strings.EqualFold("ConflictException", errorCode): 96 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 97 98 case strings.EqualFold("ForbiddenException", errorCode): 99 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 100 101 case strings.EqualFold("InternalServerErrorException", errorCode): 102 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 103 104 case strings.EqualFold("NotFoundException", errorCode): 105 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 106 107 case strings.EqualFold("TooManyRequestsException", errorCode): 108 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 109 110 default: 111 genericError := &smithy.GenericAPIError{ 112 Code: errorCode, 113 Message: errorMessage, 114 } 115 return genericError 116 117 } 118} 119 120type awsRestjson1_deserializeOpCancelJob struct { 121} 122 123func (*awsRestjson1_deserializeOpCancelJob) ID() string { 124 return "OperationDeserializer" 125} 126 127func (m *awsRestjson1_deserializeOpCancelJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 128 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 129) { 130 out, metadata, err = next.HandleDeserialize(ctx, in) 131 if err != nil { 132 return out, metadata, err 133 } 134 135 response, ok := out.RawResponse.(*smithyhttp.Response) 136 if !ok { 137 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 138 } 139 140 if response.StatusCode < 200 || response.StatusCode >= 300 { 141 return out, metadata, awsRestjson1_deserializeOpErrorCancelJob(response, &metadata) 142 } 143 output := &CancelJobOutput{} 144 out.Result = output 145 146 return out, metadata, err 147} 148 149func awsRestjson1_deserializeOpErrorCancelJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 150 var errorBuffer bytes.Buffer 151 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 152 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 153 } 154 errorBody := bytes.NewReader(errorBuffer.Bytes()) 155 156 errorCode := "UnknownError" 157 errorMessage := errorCode 158 159 code := response.Header.Get("X-Amzn-ErrorType") 160 if len(code) != 0 { 161 errorCode = restjson.SanitizeErrorCode(code) 162 } 163 164 var buff [1024]byte 165 ringBuffer := smithyio.NewRingBuffer(buff[:]) 166 167 body := io.TeeReader(errorBody, ringBuffer) 168 decoder := json.NewDecoder(body) 169 decoder.UseNumber() 170 code, message, err := restjson.GetErrorInfo(decoder) 171 if err != nil { 172 var snapshot bytes.Buffer 173 io.Copy(&snapshot, ringBuffer) 174 err = &smithy.DeserializationError{ 175 Err: fmt.Errorf("failed to decode response body, %w", err), 176 Snapshot: snapshot.Bytes(), 177 } 178 return err 179 } 180 181 errorBody.Seek(0, io.SeekStart) 182 if len(code) != 0 { 183 errorCode = restjson.SanitizeErrorCode(code) 184 } 185 if len(message) != 0 { 186 errorMessage = message 187 } 188 189 switch { 190 case strings.EqualFold("BadRequestException", errorCode): 191 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 192 193 case strings.EqualFold("ConflictException", errorCode): 194 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 195 196 case strings.EqualFold("ForbiddenException", errorCode): 197 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 198 199 case strings.EqualFold("InternalServerErrorException", errorCode): 200 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 201 202 case strings.EqualFold("NotFoundException", errorCode): 203 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 204 205 case strings.EqualFold("TooManyRequestsException", errorCode): 206 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 207 208 default: 209 genericError := &smithy.GenericAPIError{ 210 Code: errorCode, 211 Message: errorMessage, 212 } 213 return genericError 214 215 } 216} 217 218type awsRestjson1_deserializeOpCreateJob struct { 219} 220 221func (*awsRestjson1_deserializeOpCreateJob) ID() string { 222 return "OperationDeserializer" 223} 224 225func (m *awsRestjson1_deserializeOpCreateJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 226 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 227) { 228 out, metadata, err = next.HandleDeserialize(ctx, in) 229 if err != nil { 230 return out, metadata, err 231 } 232 233 response, ok := out.RawResponse.(*smithyhttp.Response) 234 if !ok { 235 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 236 } 237 238 if response.StatusCode < 200 || response.StatusCode >= 300 { 239 return out, metadata, awsRestjson1_deserializeOpErrorCreateJob(response, &metadata) 240 } 241 output := &CreateJobOutput{} 242 out.Result = output 243 244 var buff [1024]byte 245 ringBuffer := smithyio.NewRingBuffer(buff[:]) 246 247 body := io.TeeReader(response.Body, ringBuffer) 248 249 decoder := json.NewDecoder(body) 250 decoder.UseNumber() 251 var shape interface{} 252 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 253 var snapshot bytes.Buffer 254 io.Copy(&snapshot, ringBuffer) 255 err = &smithy.DeserializationError{ 256 Err: fmt.Errorf("failed to decode response body, %w", err), 257 Snapshot: snapshot.Bytes(), 258 } 259 return out, metadata, err 260 } 261 262 err = awsRestjson1_deserializeOpDocumentCreateJobOutput(&output, shape) 263 if err != nil { 264 var snapshot bytes.Buffer 265 io.Copy(&snapshot, ringBuffer) 266 return out, metadata, &smithy.DeserializationError{ 267 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 268 Snapshot: snapshot.Bytes(), 269 } 270 } 271 272 return out, metadata, err 273} 274 275func awsRestjson1_deserializeOpErrorCreateJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 276 var errorBuffer bytes.Buffer 277 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 278 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 279 } 280 errorBody := bytes.NewReader(errorBuffer.Bytes()) 281 282 errorCode := "UnknownError" 283 errorMessage := errorCode 284 285 code := response.Header.Get("X-Amzn-ErrorType") 286 if len(code) != 0 { 287 errorCode = restjson.SanitizeErrorCode(code) 288 } 289 290 var buff [1024]byte 291 ringBuffer := smithyio.NewRingBuffer(buff[:]) 292 293 body := io.TeeReader(errorBody, ringBuffer) 294 decoder := json.NewDecoder(body) 295 decoder.UseNumber() 296 code, message, err := restjson.GetErrorInfo(decoder) 297 if err != nil { 298 var snapshot bytes.Buffer 299 io.Copy(&snapshot, ringBuffer) 300 err = &smithy.DeserializationError{ 301 Err: fmt.Errorf("failed to decode response body, %w", err), 302 Snapshot: snapshot.Bytes(), 303 } 304 return err 305 } 306 307 errorBody.Seek(0, io.SeekStart) 308 if len(code) != 0 { 309 errorCode = restjson.SanitizeErrorCode(code) 310 } 311 if len(message) != 0 { 312 errorMessage = message 313 } 314 315 switch { 316 case strings.EqualFold("BadRequestException", errorCode): 317 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 318 319 case strings.EqualFold("ConflictException", errorCode): 320 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 321 322 case strings.EqualFold("ForbiddenException", errorCode): 323 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 324 325 case strings.EqualFold("InternalServerErrorException", errorCode): 326 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 327 328 case strings.EqualFold("NotFoundException", errorCode): 329 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 330 331 case strings.EqualFold("TooManyRequestsException", errorCode): 332 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 333 334 default: 335 genericError := &smithy.GenericAPIError{ 336 Code: errorCode, 337 Message: errorMessage, 338 } 339 return genericError 340 341 } 342} 343 344func awsRestjson1_deserializeOpDocumentCreateJobOutput(v **CreateJobOutput, value interface{}) error { 345 if v == nil { 346 return fmt.Errorf("unexpected nil of type %T", v) 347 } 348 if value == nil { 349 return nil 350 } 351 352 shape, ok := value.(map[string]interface{}) 353 if !ok { 354 return fmt.Errorf("unexpected JSON type %v", value) 355 } 356 357 var sv *CreateJobOutput 358 if *v == nil { 359 sv = &CreateJobOutput{} 360 } else { 361 sv = *v 362 } 363 364 for key, value := range shape { 365 switch key { 366 case "job": 367 if err := awsRestjson1_deserializeDocumentJob(&sv.Job, value); err != nil { 368 return err 369 } 370 371 default: 372 _, _ = key, value 373 374 } 375 } 376 *v = sv 377 return nil 378} 379 380type awsRestjson1_deserializeOpCreateJobTemplate struct { 381} 382 383func (*awsRestjson1_deserializeOpCreateJobTemplate) ID() string { 384 return "OperationDeserializer" 385} 386 387func (m *awsRestjson1_deserializeOpCreateJobTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 388 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 389) { 390 out, metadata, err = next.HandleDeserialize(ctx, in) 391 if err != nil { 392 return out, metadata, err 393 } 394 395 response, ok := out.RawResponse.(*smithyhttp.Response) 396 if !ok { 397 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 398 } 399 400 if response.StatusCode < 200 || response.StatusCode >= 300 { 401 return out, metadata, awsRestjson1_deserializeOpErrorCreateJobTemplate(response, &metadata) 402 } 403 output := &CreateJobTemplateOutput{} 404 out.Result = output 405 406 var buff [1024]byte 407 ringBuffer := smithyio.NewRingBuffer(buff[:]) 408 409 body := io.TeeReader(response.Body, ringBuffer) 410 411 decoder := json.NewDecoder(body) 412 decoder.UseNumber() 413 var shape interface{} 414 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 415 var snapshot bytes.Buffer 416 io.Copy(&snapshot, ringBuffer) 417 err = &smithy.DeserializationError{ 418 Err: fmt.Errorf("failed to decode response body, %w", err), 419 Snapshot: snapshot.Bytes(), 420 } 421 return out, metadata, err 422 } 423 424 err = awsRestjson1_deserializeOpDocumentCreateJobTemplateOutput(&output, shape) 425 if err != nil { 426 var snapshot bytes.Buffer 427 io.Copy(&snapshot, ringBuffer) 428 return out, metadata, &smithy.DeserializationError{ 429 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 430 Snapshot: snapshot.Bytes(), 431 } 432 } 433 434 return out, metadata, err 435} 436 437func awsRestjson1_deserializeOpErrorCreateJobTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 438 var errorBuffer bytes.Buffer 439 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 440 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 441 } 442 errorBody := bytes.NewReader(errorBuffer.Bytes()) 443 444 errorCode := "UnknownError" 445 errorMessage := errorCode 446 447 code := response.Header.Get("X-Amzn-ErrorType") 448 if len(code) != 0 { 449 errorCode = restjson.SanitizeErrorCode(code) 450 } 451 452 var buff [1024]byte 453 ringBuffer := smithyio.NewRingBuffer(buff[:]) 454 455 body := io.TeeReader(errorBody, ringBuffer) 456 decoder := json.NewDecoder(body) 457 decoder.UseNumber() 458 code, message, err := restjson.GetErrorInfo(decoder) 459 if err != nil { 460 var snapshot bytes.Buffer 461 io.Copy(&snapshot, ringBuffer) 462 err = &smithy.DeserializationError{ 463 Err: fmt.Errorf("failed to decode response body, %w", err), 464 Snapshot: snapshot.Bytes(), 465 } 466 return err 467 } 468 469 errorBody.Seek(0, io.SeekStart) 470 if len(code) != 0 { 471 errorCode = restjson.SanitizeErrorCode(code) 472 } 473 if len(message) != 0 { 474 errorMessage = message 475 } 476 477 switch { 478 case strings.EqualFold("BadRequestException", errorCode): 479 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 480 481 case strings.EqualFold("ConflictException", errorCode): 482 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 483 484 case strings.EqualFold("ForbiddenException", errorCode): 485 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 486 487 case strings.EqualFold("InternalServerErrorException", errorCode): 488 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 489 490 case strings.EqualFold("NotFoundException", errorCode): 491 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 492 493 case strings.EqualFold("TooManyRequestsException", errorCode): 494 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 495 496 default: 497 genericError := &smithy.GenericAPIError{ 498 Code: errorCode, 499 Message: errorMessage, 500 } 501 return genericError 502 503 } 504} 505 506func awsRestjson1_deserializeOpDocumentCreateJobTemplateOutput(v **CreateJobTemplateOutput, value interface{}) error { 507 if v == nil { 508 return fmt.Errorf("unexpected nil of type %T", v) 509 } 510 if value == nil { 511 return nil 512 } 513 514 shape, ok := value.(map[string]interface{}) 515 if !ok { 516 return fmt.Errorf("unexpected JSON type %v", value) 517 } 518 519 var sv *CreateJobTemplateOutput 520 if *v == nil { 521 sv = &CreateJobTemplateOutput{} 522 } else { 523 sv = *v 524 } 525 526 for key, value := range shape { 527 switch key { 528 case "jobTemplate": 529 if err := awsRestjson1_deserializeDocumentJobTemplate(&sv.JobTemplate, value); err != nil { 530 return err 531 } 532 533 default: 534 _, _ = key, value 535 536 } 537 } 538 *v = sv 539 return nil 540} 541 542type awsRestjson1_deserializeOpCreatePreset struct { 543} 544 545func (*awsRestjson1_deserializeOpCreatePreset) ID() string { 546 return "OperationDeserializer" 547} 548 549func (m *awsRestjson1_deserializeOpCreatePreset) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 550 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 551) { 552 out, metadata, err = next.HandleDeserialize(ctx, in) 553 if err != nil { 554 return out, metadata, err 555 } 556 557 response, ok := out.RawResponse.(*smithyhttp.Response) 558 if !ok { 559 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 560 } 561 562 if response.StatusCode < 200 || response.StatusCode >= 300 { 563 return out, metadata, awsRestjson1_deserializeOpErrorCreatePreset(response, &metadata) 564 } 565 output := &CreatePresetOutput{} 566 out.Result = output 567 568 var buff [1024]byte 569 ringBuffer := smithyio.NewRingBuffer(buff[:]) 570 571 body := io.TeeReader(response.Body, ringBuffer) 572 573 decoder := json.NewDecoder(body) 574 decoder.UseNumber() 575 var shape interface{} 576 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 577 var snapshot bytes.Buffer 578 io.Copy(&snapshot, ringBuffer) 579 err = &smithy.DeserializationError{ 580 Err: fmt.Errorf("failed to decode response body, %w", err), 581 Snapshot: snapshot.Bytes(), 582 } 583 return out, metadata, err 584 } 585 586 err = awsRestjson1_deserializeOpDocumentCreatePresetOutput(&output, shape) 587 if err != nil { 588 var snapshot bytes.Buffer 589 io.Copy(&snapshot, ringBuffer) 590 return out, metadata, &smithy.DeserializationError{ 591 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 592 Snapshot: snapshot.Bytes(), 593 } 594 } 595 596 return out, metadata, err 597} 598 599func awsRestjson1_deserializeOpErrorCreatePreset(response *smithyhttp.Response, metadata *middleware.Metadata) error { 600 var errorBuffer bytes.Buffer 601 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 602 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 603 } 604 errorBody := bytes.NewReader(errorBuffer.Bytes()) 605 606 errorCode := "UnknownError" 607 errorMessage := errorCode 608 609 code := response.Header.Get("X-Amzn-ErrorType") 610 if len(code) != 0 { 611 errorCode = restjson.SanitizeErrorCode(code) 612 } 613 614 var buff [1024]byte 615 ringBuffer := smithyio.NewRingBuffer(buff[:]) 616 617 body := io.TeeReader(errorBody, ringBuffer) 618 decoder := json.NewDecoder(body) 619 decoder.UseNumber() 620 code, message, err := restjson.GetErrorInfo(decoder) 621 if err != nil { 622 var snapshot bytes.Buffer 623 io.Copy(&snapshot, ringBuffer) 624 err = &smithy.DeserializationError{ 625 Err: fmt.Errorf("failed to decode response body, %w", err), 626 Snapshot: snapshot.Bytes(), 627 } 628 return err 629 } 630 631 errorBody.Seek(0, io.SeekStart) 632 if len(code) != 0 { 633 errorCode = restjson.SanitizeErrorCode(code) 634 } 635 if len(message) != 0 { 636 errorMessage = message 637 } 638 639 switch { 640 case strings.EqualFold("BadRequestException", errorCode): 641 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 642 643 case strings.EqualFold("ConflictException", errorCode): 644 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 645 646 case strings.EqualFold("ForbiddenException", errorCode): 647 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 648 649 case strings.EqualFold("InternalServerErrorException", errorCode): 650 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 651 652 case strings.EqualFold("NotFoundException", errorCode): 653 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 654 655 case strings.EqualFold("TooManyRequestsException", errorCode): 656 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 657 658 default: 659 genericError := &smithy.GenericAPIError{ 660 Code: errorCode, 661 Message: errorMessage, 662 } 663 return genericError 664 665 } 666} 667 668func awsRestjson1_deserializeOpDocumentCreatePresetOutput(v **CreatePresetOutput, value interface{}) error { 669 if v == nil { 670 return fmt.Errorf("unexpected nil of type %T", v) 671 } 672 if value == nil { 673 return nil 674 } 675 676 shape, ok := value.(map[string]interface{}) 677 if !ok { 678 return fmt.Errorf("unexpected JSON type %v", value) 679 } 680 681 var sv *CreatePresetOutput 682 if *v == nil { 683 sv = &CreatePresetOutput{} 684 } else { 685 sv = *v 686 } 687 688 for key, value := range shape { 689 switch key { 690 case "preset": 691 if err := awsRestjson1_deserializeDocumentPreset(&sv.Preset, value); err != nil { 692 return err 693 } 694 695 default: 696 _, _ = key, value 697 698 } 699 } 700 *v = sv 701 return nil 702} 703 704type awsRestjson1_deserializeOpCreateQueue struct { 705} 706 707func (*awsRestjson1_deserializeOpCreateQueue) ID() string { 708 return "OperationDeserializer" 709} 710 711func (m *awsRestjson1_deserializeOpCreateQueue) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 712 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 713) { 714 out, metadata, err = next.HandleDeserialize(ctx, in) 715 if err != nil { 716 return out, metadata, err 717 } 718 719 response, ok := out.RawResponse.(*smithyhttp.Response) 720 if !ok { 721 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 722 } 723 724 if response.StatusCode < 200 || response.StatusCode >= 300 { 725 return out, metadata, awsRestjson1_deserializeOpErrorCreateQueue(response, &metadata) 726 } 727 output := &CreateQueueOutput{} 728 out.Result = output 729 730 var buff [1024]byte 731 ringBuffer := smithyio.NewRingBuffer(buff[:]) 732 733 body := io.TeeReader(response.Body, ringBuffer) 734 735 decoder := json.NewDecoder(body) 736 decoder.UseNumber() 737 var shape interface{} 738 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 739 var snapshot bytes.Buffer 740 io.Copy(&snapshot, ringBuffer) 741 err = &smithy.DeserializationError{ 742 Err: fmt.Errorf("failed to decode response body, %w", err), 743 Snapshot: snapshot.Bytes(), 744 } 745 return out, metadata, err 746 } 747 748 err = awsRestjson1_deserializeOpDocumentCreateQueueOutput(&output, shape) 749 if err != nil { 750 var snapshot bytes.Buffer 751 io.Copy(&snapshot, ringBuffer) 752 return out, metadata, &smithy.DeserializationError{ 753 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 754 Snapshot: snapshot.Bytes(), 755 } 756 } 757 758 return out, metadata, err 759} 760 761func awsRestjson1_deserializeOpErrorCreateQueue(response *smithyhttp.Response, metadata *middleware.Metadata) error { 762 var errorBuffer bytes.Buffer 763 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 764 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 765 } 766 errorBody := bytes.NewReader(errorBuffer.Bytes()) 767 768 errorCode := "UnknownError" 769 errorMessage := errorCode 770 771 code := response.Header.Get("X-Amzn-ErrorType") 772 if len(code) != 0 { 773 errorCode = restjson.SanitizeErrorCode(code) 774 } 775 776 var buff [1024]byte 777 ringBuffer := smithyio.NewRingBuffer(buff[:]) 778 779 body := io.TeeReader(errorBody, ringBuffer) 780 decoder := json.NewDecoder(body) 781 decoder.UseNumber() 782 code, message, err := restjson.GetErrorInfo(decoder) 783 if err != nil { 784 var snapshot bytes.Buffer 785 io.Copy(&snapshot, ringBuffer) 786 err = &smithy.DeserializationError{ 787 Err: fmt.Errorf("failed to decode response body, %w", err), 788 Snapshot: snapshot.Bytes(), 789 } 790 return err 791 } 792 793 errorBody.Seek(0, io.SeekStart) 794 if len(code) != 0 { 795 errorCode = restjson.SanitizeErrorCode(code) 796 } 797 if len(message) != 0 { 798 errorMessage = message 799 } 800 801 switch { 802 case strings.EqualFold("BadRequestException", errorCode): 803 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 804 805 case strings.EqualFold("ConflictException", errorCode): 806 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 807 808 case strings.EqualFold("ForbiddenException", errorCode): 809 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 810 811 case strings.EqualFold("InternalServerErrorException", errorCode): 812 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 813 814 case strings.EqualFold("NotFoundException", errorCode): 815 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 816 817 case strings.EqualFold("TooManyRequestsException", errorCode): 818 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 819 820 default: 821 genericError := &smithy.GenericAPIError{ 822 Code: errorCode, 823 Message: errorMessage, 824 } 825 return genericError 826 827 } 828} 829 830func awsRestjson1_deserializeOpDocumentCreateQueueOutput(v **CreateQueueOutput, value interface{}) error { 831 if v == nil { 832 return fmt.Errorf("unexpected nil of type %T", v) 833 } 834 if value == nil { 835 return nil 836 } 837 838 shape, ok := value.(map[string]interface{}) 839 if !ok { 840 return fmt.Errorf("unexpected JSON type %v", value) 841 } 842 843 var sv *CreateQueueOutput 844 if *v == nil { 845 sv = &CreateQueueOutput{} 846 } else { 847 sv = *v 848 } 849 850 for key, value := range shape { 851 switch key { 852 case "queue": 853 if err := awsRestjson1_deserializeDocumentQueue(&sv.Queue, value); err != nil { 854 return err 855 } 856 857 default: 858 _, _ = key, value 859 860 } 861 } 862 *v = sv 863 return nil 864} 865 866type awsRestjson1_deserializeOpDeleteJobTemplate struct { 867} 868 869func (*awsRestjson1_deserializeOpDeleteJobTemplate) ID() string { 870 return "OperationDeserializer" 871} 872 873func (m *awsRestjson1_deserializeOpDeleteJobTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 874 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 875) { 876 out, metadata, err = next.HandleDeserialize(ctx, in) 877 if err != nil { 878 return out, metadata, err 879 } 880 881 response, ok := out.RawResponse.(*smithyhttp.Response) 882 if !ok { 883 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 884 } 885 886 if response.StatusCode < 200 || response.StatusCode >= 300 { 887 return out, metadata, awsRestjson1_deserializeOpErrorDeleteJobTemplate(response, &metadata) 888 } 889 output := &DeleteJobTemplateOutput{} 890 out.Result = output 891 892 return out, metadata, err 893} 894 895func awsRestjson1_deserializeOpErrorDeleteJobTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 896 var errorBuffer bytes.Buffer 897 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 898 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 899 } 900 errorBody := bytes.NewReader(errorBuffer.Bytes()) 901 902 errorCode := "UnknownError" 903 errorMessage := errorCode 904 905 code := response.Header.Get("X-Amzn-ErrorType") 906 if len(code) != 0 { 907 errorCode = restjson.SanitizeErrorCode(code) 908 } 909 910 var buff [1024]byte 911 ringBuffer := smithyio.NewRingBuffer(buff[:]) 912 913 body := io.TeeReader(errorBody, ringBuffer) 914 decoder := json.NewDecoder(body) 915 decoder.UseNumber() 916 code, message, err := restjson.GetErrorInfo(decoder) 917 if err != nil { 918 var snapshot bytes.Buffer 919 io.Copy(&snapshot, ringBuffer) 920 err = &smithy.DeserializationError{ 921 Err: fmt.Errorf("failed to decode response body, %w", err), 922 Snapshot: snapshot.Bytes(), 923 } 924 return err 925 } 926 927 errorBody.Seek(0, io.SeekStart) 928 if len(code) != 0 { 929 errorCode = restjson.SanitizeErrorCode(code) 930 } 931 if len(message) != 0 { 932 errorMessage = message 933 } 934 935 switch { 936 case strings.EqualFold("BadRequestException", errorCode): 937 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 938 939 case strings.EqualFold("ConflictException", errorCode): 940 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 941 942 case strings.EqualFold("ForbiddenException", errorCode): 943 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 944 945 case strings.EqualFold("InternalServerErrorException", errorCode): 946 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 947 948 case strings.EqualFold("NotFoundException", errorCode): 949 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 950 951 case strings.EqualFold("TooManyRequestsException", errorCode): 952 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 953 954 default: 955 genericError := &smithy.GenericAPIError{ 956 Code: errorCode, 957 Message: errorMessage, 958 } 959 return genericError 960 961 } 962} 963 964type awsRestjson1_deserializeOpDeletePreset struct { 965} 966 967func (*awsRestjson1_deserializeOpDeletePreset) ID() string { 968 return "OperationDeserializer" 969} 970 971func (m *awsRestjson1_deserializeOpDeletePreset) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 972 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 973) { 974 out, metadata, err = next.HandleDeserialize(ctx, in) 975 if err != nil { 976 return out, metadata, err 977 } 978 979 response, ok := out.RawResponse.(*smithyhttp.Response) 980 if !ok { 981 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 982 } 983 984 if response.StatusCode < 200 || response.StatusCode >= 300 { 985 return out, metadata, awsRestjson1_deserializeOpErrorDeletePreset(response, &metadata) 986 } 987 output := &DeletePresetOutput{} 988 out.Result = output 989 990 return out, metadata, err 991} 992 993func awsRestjson1_deserializeOpErrorDeletePreset(response *smithyhttp.Response, metadata *middleware.Metadata) error { 994 var errorBuffer bytes.Buffer 995 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 996 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 997 } 998 errorBody := bytes.NewReader(errorBuffer.Bytes()) 999 1000 errorCode := "UnknownError" 1001 errorMessage := errorCode 1002 1003 code := response.Header.Get("X-Amzn-ErrorType") 1004 if len(code) != 0 { 1005 errorCode = restjson.SanitizeErrorCode(code) 1006 } 1007 1008 var buff [1024]byte 1009 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1010 1011 body := io.TeeReader(errorBody, ringBuffer) 1012 decoder := json.NewDecoder(body) 1013 decoder.UseNumber() 1014 code, message, err := restjson.GetErrorInfo(decoder) 1015 if err != nil { 1016 var snapshot bytes.Buffer 1017 io.Copy(&snapshot, ringBuffer) 1018 err = &smithy.DeserializationError{ 1019 Err: fmt.Errorf("failed to decode response body, %w", err), 1020 Snapshot: snapshot.Bytes(), 1021 } 1022 return err 1023 } 1024 1025 errorBody.Seek(0, io.SeekStart) 1026 if len(code) != 0 { 1027 errorCode = restjson.SanitizeErrorCode(code) 1028 } 1029 if len(message) != 0 { 1030 errorMessage = message 1031 } 1032 1033 switch { 1034 case strings.EqualFold("BadRequestException", errorCode): 1035 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1036 1037 case strings.EqualFold("ConflictException", errorCode): 1038 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1039 1040 case strings.EqualFold("ForbiddenException", errorCode): 1041 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1042 1043 case strings.EqualFold("InternalServerErrorException", errorCode): 1044 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1045 1046 case strings.EqualFold("NotFoundException", errorCode): 1047 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1048 1049 case strings.EqualFold("TooManyRequestsException", errorCode): 1050 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1051 1052 default: 1053 genericError := &smithy.GenericAPIError{ 1054 Code: errorCode, 1055 Message: errorMessage, 1056 } 1057 return genericError 1058 1059 } 1060} 1061 1062type awsRestjson1_deserializeOpDeleteQueue struct { 1063} 1064 1065func (*awsRestjson1_deserializeOpDeleteQueue) ID() string { 1066 return "OperationDeserializer" 1067} 1068 1069func (m *awsRestjson1_deserializeOpDeleteQueue) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1070 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1071) { 1072 out, metadata, err = next.HandleDeserialize(ctx, in) 1073 if err != nil { 1074 return out, metadata, err 1075 } 1076 1077 response, ok := out.RawResponse.(*smithyhttp.Response) 1078 if !ok { 1079 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1080 } 1081 1082 if response.StatusCode < 200 || response.StatusCode >= 300 { 1083 return out, metadata, awsRestjson1_deserializeOpErrorDeleteQueue(response, &metadata) 1084 } 1085 output := &DeleteQueueOutput{} 1086 out.Result = output 1087 1088 return out, metadata, err 1089} 1090 1091func awsRestjson1_deserializeOpErrorDeleteQueue(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1092 var errorBuffer bytes.Buffer 1093 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1094 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1095 } 1096 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1097 1098 errorCode := "UnknownError" 1099 errorMessage := errorCode 1100 1101 code := response.Header.Get("X-Amzn-ErrorType") 1102 if len(code) != 0 { 1103 errorCode = restjson.SanitizeErrorCode(code) 1104 } 1105 1106 var buff [1024]byte 1107 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1108 1109 body := io.TeeReader(errorBody, ringBuffer) 1110 decoder := json.NewDecoder(body) 1111 decoder.UseNumber() 1112 code, message, err := restjson.GetErrorInfo(decoder) 1113 if err != nil { 1114 var snapshot bytes.Buffer 1115 io.Copy(&snapshot, ringBuffer) 1116 err = &smithy.DeserializationError{ 1117 Err: fmt.Errorf("failed to decode response body, %w", err), 1118 Snapshot: snapshot.Bytes(), 1119 } 1120 return err 1121 } 1122 1123 errorBody.Seek(0, io.SeekStart) 1124 if len(code) != 0 { 1125 errorCode = restjson.SanitizeErrorCode(code) 1126 } 1127 if len(message) != 0 { 1128 errorMessage = message 1129 } 1130 1131 switch { 1132 case strings.EqualFold("BadRequestException", errorCode): 1133 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1134 1135 case strings.EqualFold("ConflictException", errorCode): 1136 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1137 1138 case strings.EqualFold("ForbiddenException", errorCode): 1139 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1140 1141 case strings.EqualFold("InternalServerErrorException", errorCode): 1142 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1143 1144 case strings.EqualFold("NotFoundException", errorCode): 1145 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1146 1147 case strings.EqualFold("TooManyRequestsException", errorCode): 1148 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1149 1150 default: 1151 genericError := &smithy.GenericAPIError{ 1152 Code: errorCode, 1153 Message: errorMessage, 1154 } 1155 return genericError 1156 1157 } 1158} 1159 1160type awsRestjson1_deserializeOpDescribeEndpoints struct { 1161} 1162 1163func (*awsRestjson1_deserializeOpDescribeEndpoints) ID() string { 1164 return "OperationDeserializer" 1165} 1166 1167func (m *awsRestjson1_deserializeOpDescribeEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1168 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1169) { 1170 out, metadata, err = next.HandleDeserialize(ctx, in) 1171 if err != nil { 1172 return out, metadata, err 1173 } 1174 1175 response, ok := out.RawResponse.(*smithyhttp.Response) 1176 if !ok { 1177 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1178 } 1179 1180 if response.StatusCode < 200 || response.StatusCode >= 300 { 1181 return out, metadata, awsRestjson1_deserializeOpErrorDescribeEndpoints(response, &metadata) 1182 } 1183 output := &DescribeEndpointsOutput{} 1184 out.Result = output 1185 1186 var buff [1024]byte 1187 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1188 1189 body := io.TeeReader(response.Body, ringBuffer) 1190 1191 decoder := json.NewDecoder(body) 1192 decoder.UseNumber() 1193 var shape interface{} 1194 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1195 var snapshot bytes.Buffer 1196 io.Copy(&snapshot, ringBuffer) 1197 err = &smithy.DeserializationError{ 1198 Err: fmt.Errorf("failed to decode response body, %w", err), 1199 Snapshot: snapshot.Bytes(), 1200 } 1201 return out, metadata, err 1202 } 1203 1204 err = awsRestjson1_deserializeOpDocumentDescribeEndpointsOutput(&output, shape) 1205 if err != nil { 1206 var snapshot bytes.Buffer 1207 io.Copy(&snapshot, ringBuffer) 1208 return out, metadata, &smithy.DeserializationError{ 1209 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1210 Snapshot: snapshot.Bytes(), 1211 } 1212 } 1213 1214 return out, metadata, err 1215} 1216 1217func awsRestjson1_deserializeOpErrorDescribeEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1218 var errorBuffer bytes.Buffer 1219 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1220 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1221 } 1222 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1223 1224 errorCode := "UnknownError" 1225 errorMessage := errorCode 1226 1227 code := response.Header.Get("X-Amzn-ErrorType") 1228 if len(code) != 0 { 1229 errorCode = restjson.SanitizeErrorCode(code) 1230 } 1231 1232 var buff [1024]byte 1233 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1234 1235 body := io.TeeReader(errorBody, ringBuffer) 1236 decoder := json.NewDecoder(body) 1237 decoder.UseNumber() 1238 code, message, err := restjson.GetErrorInfo(decoder) 1239 if err != nil { 1240 var snapshot bytes.Buffer 1241 io.Copy(&snapshot, ringBuffer) 1242 err = &smithy.DeserializationError{ 1243 Err: fmt.Errorf("failed to decode response body, %w", err), 1244 Snapshot: snapshot.Bytes(), 1245 } 1246 return err 1247 } 1248 1249 errorBody.Seek(0, io.SeekStart) 1250 if len(code) != 0 { 1251 errorCode = restjson.SanitizeErrorCode(code) 1252 } 1253 if len(message) != 0 { 1254 errorMessage = message 1255 } 1256 1257 switch { 1258 case strings.EqualFold("BadRequestException", errorCode): 1259 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1260 1261 case strings.EqualFold("ConflictException", errorCode): 1262 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1263 1264 case strings.EqualFold("ForbiddenException", errorCode): 1265 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1266 1267 case strings.EqualFold("InternalServerErrorException", errorCode): 1268 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1269 1270 case strings.EqualFold("NotFoundException", errorCode): 1271 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1272 1273 case strings.EqualFold("TooManyRequestsException", errorCode): 1274 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1275 1276 default: 1277 genericError := &smithy.GenericAPIError{ 1278 Code: errorCode, 1279 Message: errorMessage, 1280 } 1281 return genericError 1282 1283 } 1284} 1285 1286func awsRestjson1_deserializeOpDocumentDescribeEndpointsOutput(v **DescribeEndpointsOutput, value interface{}) error { 1287 if v == nil { 1288 return fmt.Errorf("unexpected nil of type %T", v) 1289 } 1290 if value == nil { 1291 return nil 1292 } 1293 1294 shape, ok := value.(map[string]interface{}) 1295 if !ok { 1296 return fmt.Errorf("unexpected JSON type %v", value) 1297 } 1298 1299 var sv *DescribeEndpointsOutput 1300 if *v == nil { 1301 sv = &DescribeEndpointsOutput{} 1302 } else { 1303 sv = *v 1304 } 1305 1306 for key, value := range shape { 1307 switch key { 1308 case "endpoints": 1309 if err := awsRestjson1_deserializeDocument__listOfEndpoint(&sv.Endpoints, value); err != nil { 1310 return err 1311 } 1312 1313 case "nextToken": 1314 if value != nil { 1315 jtv, ok := value.(string) 1316 if !ok { 1317 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 1318 } 1319 sv.NextToken = ptr.String(jtv) 1320 } 1321 1322 default: 1323 _, _ = key, value 1324 1325 } 1326 } 1327 *v = sv 1328 return nil 1329} 1330 1331type awsRestjson1_deserializeOpDisassociateCertificate struct { 1332} 1333 1334func (*awsRestjson1_deserializeOpDisassociateCertificate) ID() string { 1335 return "OperationDeserializer" 1336} 1337 1338func (m *awsRestjson1_deserializeOpDisassociateCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1339 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1340) { 1341 out, metadata, err = next.HandleDeserialize(ctx, in) 1342 if err != nil { 1343 return out, metadata, err 1344 } 1345 1346 response, ok := out.RawResponse.(*smithyhttp.Response) 1347 if !ok { 1348 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1349 } 1350 1351 if response.StatusCode < 200 || response.StatusCode >= 300 { 1352 return out, metadata, awsRestjson1_deserializeOpErrorDisassociateCertificate(response, &metadata) 1353 } 1354 output := &DisassociateCertificateOutput{} 1355 out.Result = output 1356 1357 return out, metadata, err 1358} 1359 1360func awsRestjson1_deserializeOpErrorDisassociateCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1361 var errorBuffer bytes.Buffer 1362 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1363 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1364 } 1365 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1366 1367 errorCode := "UnknownError" 1368 errorMessage := errorCode 1369 1370 code := response.Header.Get("X-Amzn-ErrorType") 1371 if len(code) != 0 { 1372 errorCode = restjson.SanitizeErrorCode(code) 1373 } 1374 1375 var buff [1024]byte 1376 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1377 1378 body := io.TeeReader(errorBody, ringBuffer) 1379 decoder := json.NewDecoder(body) 1380 decoder.UseNumber() 1381 code, message, err := restjson.GetErrorInfo(decoder) 1382 if err != nil { 1383 var snapshot bytes.Buffer 1384 io.Copy(&snapshot, ringBuffer) 1385 err = &smithy.DeserializationError{ 1386 Err: fmt.Errorf("failed to decode response body, %w", err), 1387 Snapshot: snapshot.Bytes(), 1388 } 1389 return err 1390 } 1391 1392 errorBody.Seek(0, io.SeekStart) 1393 if len(code) != 0 { 1394 errorCode = restjson.SanitizeErrorCode(code) 1395 } 1396 if len(message) != 0 { 1397 errorMessage = message 1398 } 1399 1400 switch { 1401 case strings.EqualFold("BadRequestException", errorCode): 1402 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1403 1404 case strings.EqualFold("ConflictException", errorCode): 1405 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1406 1407 case strings.EqualFold("ForbiddenException", errorCode): 1408 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1409 1410 case strings.EqualFold("InternalServerErrorException", errorCode): 1411 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1412 1413 case strings.EqualFold("NotFoundException", errorCode): 1414 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1415 1416 case strings.EqualFold("TooManyRequestsException", errorCode): 1417 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1418 1419 default: 1420 genericError := &smithy.GenericAPIError{ 1421 Code: errorCode, 1422 Message: errorMessage, 1423 } 1424 return genericError 1425 1426 } 1427} 1428 1429type awsRestjson1_deserializeOpGetJob struct { 1430} 1431 1432func (*awsRestjson1_deserializeOpGetJob) ID() string { 1433 return "OperationDeserializer" 1434} 1435 1436func (m *awsRestjson1_deserializeOpGetJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1437 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1438) { 1439 out, metadata, err = next.HandleDeserialize(ctx, in) 1440 if err != nil { 1441 return out, metadata, err 1442 } 1443 1444 response, ok := out.RawResponse.(*smithyhttp.Response) 1445 if !ok { 1446 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1447 } 1448 1449 if response.StatusCode < 200 || response.StatusCode >= 300 { 1450 return out, metadata, awsRestjson1_deserializeOpErrorGetJob(response, &metadata) 1451 } 1452 output := &GetJobOutput{} 1453 out.Result = output 1454 1455 var buff [1024]byte 1456 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1457 1458 body := io.TeeReader(response.Body, ringBuffer) 1459 1460 decoder := json.NewDecoder(body) 1461 decoder.UseNumber() 1462 var shape interface{} 1463 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1464 var snapshot bytes.Buffer 1465 io.Copy(&snapshot, ringBuffer) 1466 err = &smithy.DeserializationError{ 1467 Err: fmt.Errorf("failed to decode response body, %w", err), 1468 Snapshot: snapshot.Bytes(), 1469 } 1470 return out, metadata, err 1471 } 1472 1473 err = awsRestjson1_deserializeOpDocumentGetJobOutput(&output, shape) 1474 if err != nil { 1475 var snapshot bytes.Buffer 1476 io.Copy(&snapshot, ringBuffer) 1477 return out, metadata, &smithy.DeserializationError{ 1478 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1479 Snapshot: snapshot.Bytes(), 1480 } 1481 } 1482 1483 return out, metadata, err 1484} 1485 1486func awsRestjson1_deserializeOpErrorGetJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1487 var errorBuffer bytes.Buffer 1488 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1489 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1490 } 1491 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1492 1493 errorCode := "UnknownError" 1494 errorMessage := errorCode 1495 1496 code := response.Header.Get("X-Amzn-ErrorType") 1497 if len(code) != 0 { 1498 errorCode = restjson.SanitizeErrorCode(code) 1499 } 1500 1501 var buff [1024]byte 1502 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1503 1504 body := io.TeeReader(errorBody, ringBuffer) 1505 decoder := json.NewDecoder(body) 1506 decoder.UseNumber() 1507 code, message, err := restjson.GetErrorInfo(decoder) 1508 if err != nil { 1509 var snapshot bytes.Buffer 1510 io.Copy(&snapshot, ringBuffer) 1511 err = &smithy.DeserializationError{ 1512 Err: fmt.Errorf("failed to decode response body, %w", err), 1513 Snapshot: snapshot.Bytes(), 1514 } 1515 return err 1516 } 1517 1518 errorBody.Seek(0, io.SeekStart) 1519 if len(code) != 0 { 1520 errorCode = restjson.SanitizeErrorCode(code) 1521 } 1522 if len(message) != 0 { 1523 errorMessage = message 1524 } 1525 1526 switch { 1527 case strings.EqualFold("BadRequestException", errorCode): 1528 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1529 1530 case strings.EqualFold("ConflictException", errorCode): 1531 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1532 1533 case strings.EqualFold("ForbiddenException", errorCode): 1534 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1535 1536 case strings.EqualFold("InternalServerErrorException", errorCode): 1537 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1538 1539 case strings.EqualFold("NotFoundException", errorCode): 1540 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1541 1542 case strings.EqualFold("TooManyRequestsException", errorCode): 1543 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1544 1545 default: 1546 genericError := &smithy.GenericAPIError{ 1547 Code: errorCode, 1548 Message: errorMessage, 1549 } 1550 return genericError 1551 1552 } 1553} 1554 1555func awsRestjson1_deserializeOpDocumentGetJobOutput(v **GetJobOutput, value interface{}) error { 1556 if v == nil { 1557 return fmt.Errorf("unexpected nil of type %T", v) 1558 } 1559 if value == nil { 1560 return nil 1561 } 1562 1563 shape, ok := value.(map[string]interface{}) 1564 if !ok { 1565 return fmt.Errorf("unexpected JSON type %v", value) 1566 } 1567 1568 var sv *GetJobOutput 1569 if *v == nil { 1570 sv = &GetJobOutput{} 1571 } else { 1572 sv = *v 1573 } 1574 1575 for key, value := range shape { 1576 switch key { 1577 case "job": 1578 if err := awsRestjson1_deserializeDocumentJob(&sv.Job, value); err != nil { 1579 return err 1580 } 1581 1582 default: 1583 _, _ = key, value 1584 1585 } 1586 } 1587 *v = sv 1588 return nil 1589} 1590 1591type awsRestjson1_deserializeOpGetJobTemplate struct { 1592} 1593 1594func (*awsRestjson1_deserializeOpGetJobTemplate) ID() string { 1595 return "OperationDeserializer" 1596} 1597 1598func (m *awsRestjson1_deserializeOpGetJobTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1599 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1600) { 1601 out, metadata, err = next.HandleDeserialize(ctx, in) 1602 if err != nil { 1603 return out, metadata, err 1604 } 1605 1606 response, ok := out.RawResponse.(*smithyhttp.Response) 1607 if !ok { 1608 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1609 } 1610 1611 if response.StatusCode < 200 || response.StatusCode >= 300 { 1612 return out, metadata, awsRestjson1_deserializeOpErrorGetJobTemplate(response, &metadata) 1613 } 1614 output := &GetJobTemplateOutput{} 1615 out.Result = output 1616 1617 var buff [1024]byte 1618 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1619 1620 body := io.TeeReader(response.Body, ringBuffer) 1621 1622 decoder := json.NewDecoder(body) 1623 decoder.UseNumber() 1624 var shape interface{} 1625 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1626 var snapshot bytes.Buffer 1627 io.Copy(&snapshot, ringBuffer) 1628 err = &smithy.DeserializationError{ 1629 Err: fmt.Errorf("failed to decode response body, %w", err), 1630 Snapshot: snapshot.Bytes(), 1631 } 1632 return out, metadata, err 1633 } 1634 1635 err = awsRestjson1_deserializeOpDocumentGetJobTemplateOutput(&output, shape) 1636 if err != nil { 1637 var snapshot bytes.Buffer 1638 io.Copy(&snapshot, ringBuffer) 1639 return out, metadata, &smithy.DeserializationError{ 1640 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1641 Snapshot: snapshot.Bytes(), 1642 } 1643 } 1644 1645 return out, metadata, err 1646} 1647 1648func awsRestjson1_deserializeOpErrorGetJobTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1649 var errorBuffer bytes.Buffer 1650 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1651 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1652 } 1653 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1654 1655 errorCode := "UnknownError" 1656 errorMessage := errorCode 1657 1658 code := response.Header.Get("X-Amzn-ErrorType") 1659 if len(code) != 0 { 1660 errorCode = restjson.SanitizeErrorCode(code) 1661 } 1662 1663 var buff [1024]byte 1664 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1665 1666 body := io.TeeReader(errorBody, ringBuffer) 1667 decoder := json.NewDecoder(body) 1668 decoder.UseNumber() 1669 code, message, err := restjson.GetErrorInfo(decoder) 1670 if err != nil { 1671 var snapshot bytes.Buffer 1672 io.Copy(&snapshot, ringBuffer) 1673 err = &smithy.DeserializationError{ 1674 Err: fmt.Errorf("failed to decode response body, %w", err), 1675 Snapshot: snapshot.Bytes(), 1676 } 1677 return err 1678 } 1679 1680 errorBody.Seek(0, io.SeekStart) 1681 if len(code) != 0 { 1682 errorCode = restjson.SanitizeErrorCode(code) 1683 } 1684 if len(message) != 0 { 1685 errorMessage = message 1686 } 1687 1688 switch { 1689 case strings.EqualFold("BadRequestException", errorCode): 1690 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1691 1692 case strings.EqualFold("ConflictException", errorCode): 1693 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1694 1695 case strings.EqualFold("ForbiddenException", errorCode): 1696 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1697 1698 case strings.EqualFold("InternalServerErrorException", errorCode): 1699 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1700 1701 case strings.EqualFold("NotFoundException", errorCode): 1702 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1703 1704 case strings.EqualFold("TooManyRequestsException", errorCode): 1705 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1706 1707 default: 1708 genericError := &smithy.GenericAPIError{ 1709 Code: errorCode, 1710 Message: errorMessage, 1711 } 1712 return genericError 1713 1714 } 1715} 1716 1717func awsRestjson1_deserializeOpDocumentGetJobTemplateOutput(v **GetJobTemplateOutput, value interface{}) error { 1718 if v == nil { 1719 return fmt.Errorf("unexpected nil of type %T", v) 1720 } 1721 if value == nil { 1722 return nil 1723 } 1724 1725 shape, ok := value.(map[string]interface{}) 1726 if !ok { 1727 return fmt.Errorf("unexpected JSON type %v", value) 1728 } 1729 1730 var sv *GetJobTemplateOutput 1731 if *v == nil { 1732 sv = &GetJobTemplateOutput{} 1733 } else { 1734 sv = *v 1735 } 1736 1737 for key, value := range shape { 1738 switch key { 1739 case "jobTemplate": 1740 if err := awsRestjson1_deserializeDocumentJobTemplate(&sv.JobTemplate, value); err != nil { 1741 return err 1742 } 1743 1744 default: 1745 _, _ = key, value 1746 1747 } 1748 } 1749 *v = sv 1750 return nil 1751} 1752 1753type awsRestjson1_deserializeOpGetPreset struct { 1754} 1755 1756func (*awsRestjson1_deserializeOpGetPreset) ID() string { 1757 return "OperationDeserializer" 1758} 1759 1760func (m *awsRestjson1_deserializeOpGetPreset) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1761 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1762) { 1763 out, metadata, err = next.HandleDeserialize(ctx, in) 1764 if err != nil { 1765 return out, metadata, err 1766 } 1767 1768 response, ok := out.RawResponse.(*smithyhttp.Response) 1769 if !ok { 1770 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1771 } 1772 1773 if response.StatusCode < 200 || response.StatusCode >= 300 { 1774 return out, metadata, awsRestjson1_deserializeOpErrorGetPreset(response, &metadata) 1775 } 1776 output := &GetPresetOutput{} 1777 out.Result = output 1778 1779 var buff [1024]byte 1780 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1781 1782 body := io.TeeReader(response.Body, ringBuffer) 1783 1784 decoder := json.NewDecoder(body) 1785 decoder.UseNumber() 1786 var shape interface{} 1787 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1788 var snapshot bytes.Buffer 1789 io.Copy(&snapshot, ringBuffer) 1790 err = &smithy.DeserializationError{ 1791 Err: fmt.Errorf("failed to decode response body, %w", err), 1792 Snapshot: snapshot.Bytes(), 1793 } 1794 return out, metadata, err 1795 } 1796 1797 err = awsRestjson1_deserializeOpDocumentGetPresetOutput(&output, shape) 1798 if err != nil { 1799 var snapshot bytes.Buffer 1800 io.Copy(&snapshot, ringBuffer) 1801 return out, metadata, &smithy.DeserializationError{ 1802 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1803 Snapshot: snapshot.Bytes(), 1804 } 1805 } 1806 1807 return out, metadata, err 1808} 1809 1810func awsRestjson1_deserializeOpErrorGetPreset(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1811 var errorBuffer bytes.Buffer 1812 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1813 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1814 } 1815 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1816 1817 errorCode := "UnknownError" 1818 errorMessage := errorCode 1819 1820 code := response.Header.Get("X-Amzn-ErrorType") 1821 if len(code) != 0 { 1822 errorCode = restjson.SanitizeErrorCode(code) 1823 } 1824 1825 var buff [1024]byte 1826 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1827 1828 body := io.TeeReader(errorBody, ringBuffer) 1829 decoder := json.NewDecoder(body) 1830 decoder.UseNumber() 1831 code, message, err := restjson.GetErrorInfo(decoder) 1832 if err != nil { 1833 var snapshot bytes.Buffer 1834 io.Copy(&snapshot, ringBuffer) 1835 err = &smithy.DeserializationError{ 1836 Err: fmt.Errorf("failed to decode response body, %w", err), 1837 Snapshot: snapshot.Bytes(), 1838 } 1839 return err 1840 } 1841 1842 errorBody.Seek(0, io.SeekStart) 1843 if len(code) != 0 { 1844 errorCode = restjson.SanitizeErrorCode(code) 1845 } 1846 if len(message) != 0 { 1847 errorMessage = message 1848 } 1849 1850 switch { 1851 case strings.EqualFold("BadRequestException", errorCode): 1852 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1853 1854 case strings.EqualFold("ConflictException", errorCode): 1855 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1856 1857 case strings.EqualFold("ForbiddenException", errorCode): 1858 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1859 1860 case strings.EqualFold("InternalServerErrorException", errorCode): 1861 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1862 1863 case strings.EqualFold("NotFoundException", errorCode): 1864 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1865 1866 case strings.EqualFold("TooManyRequestsException", errorCode): 1867 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1868 1869 default: 1870 genericError := &smithy.GenericAPIError{ 1871 Code: errorCode, 1872 Message: errorMessage, 1873 } 1874 return genericError 1875 1876 } 1877} 1878 1879func awsRestjson1_deserializeOpDocumentGetPresetOutput(v **GetPresetOutput, value interface{}) error { 1880 if v == nil { 1881 return fmt.Errorf("unexpected nil of type %T", v) 1882 } 1883 if value == nil { 1884 return nil 1885 } 1886 1887 shape, ok := value.(map[string]interface{}) 1888 if !ok { 1889 return fmt.Errorf("unexpected JSON type %v", value) 1890 } 1891 1892 var sv *GetPresetOutput 1893 if *v == nil { 1894 sv = &GetPresetOutput{} 1895 } else { 1896 sv = *v 1897 } 1898 1899 for key, value := range shape { 1900 switch key { 1901 case "preset": 1902 if err := awsRestjson1_deserializeDocumentPreset(&sv.Preset, value); err != nil { 1903 return err 1904 } 1905 1906 default: 1907 _, _ = key, value 1908 1909 } 1910 } 1911 *v = sv 1912 return nil 1913} 1914 1915type awsRestjson1_deserializeOpGetQueue struct { 1916} 1917 1918func (*awsRestjson1_deserializeOpGetQueue) ID() string { 1919 return "OperationDeserializer" 1920} 1921 1922func (m *awsRestjson1_deserializeOpGetQueue) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1923 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1924) { 1925 out, metadata, err = next.HandleDeserialize(ctx, in) 1926 if err != nil { 1927 return out, metadata, err 1928 } 1929 1930 response, ok := out.RawResponse.(*smithyhttp.Response) 1931 if !ok { 1932 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1933 } 1934 1935 if response.StatusCode < 200 || response.StatusCode >= 300 { 1936 return out, metadata, awsRestjson1_deserializeOpErrorGetQueue(response, &metadata) 1937 } 1938 output := &GetQueueOutput{} 1939 out.Result = output 1940 1941 var buff [1024]byte 1942 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1943 1944 body := io.TeeReader(response.Body, ringBuffer) 1945 1946 decoder := json.NewDecoder(body) 1947 decoder.UseNumber() 1948 var shape interface{} 1949 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1950 var snapshot bytes.Buffer 1951 io.Copy(&snapshot, ringBuffer) 1952 err = &smithy.DeserializationError{ 1953 Err: fmt.Errorf("failed to decode response body, %w", err), 1954 Snapshot: snapshot.Bytes(), 1955 } 1956 return out, metadata, err 1957 } 1958 1959 err = awsRestjson1_deserializeOpDocumentGetQueueOutput(&output, shape) 1960 if err != nil { 1961 var snapshot bytes.Buffer 1962 io.Copy(&snapshot, ringBuffer) 1963 return out, metadata, &smithy.DeserializationError{ 1964 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1965 Snapshot: snapshot.Bytes(), 1966 } 1967 } 1968 1969 return out, metadata, err 1970} 1971 1972func awsRestjson1_deserializeOpErrorGetQueue(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1973 var errorBuffer bytes.Buffer 1974 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1975 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1976 } 1977 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1978 1979 errorCode := "UnknownError" 1980 errorMessage := errorCode 1981 1982 code := response.Header.Get("X-Amzn-ErrorType") 1983 if len(code) != 0 { 1984 errorCode = restjson.SanitizeErrorCode(code) 1985 } 1986 1987 var buff [1024]byte 1988 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1989 1990 body := io.TeeReader(errorBody, ringBuffer) 1991 decoder := json.NewDecoder(body) 1992 decoder.UseNumber() 1993 code, message, err := restjson.GetErrorInfo(decoder) 1994 if err != nil { 1995 var snapshot bytes.Buffer 1996 io.Copy(&snapshot, ringBuffer) 1997 err = &smithy.DeserializationError{ 1998 Err: fmt.Errorf("failed to decode response body, %w", err), 1999 Snapshot: snapshot.Bytes(), 2000 } 2001 return err 2002 } 2003 2004 errorBody.Seek(0, io.SeekStart) 2005 if len(code) != 0 { 2006 errorCode = restjson.SanitizeErrorCode(code) 2007 } 2008 if len(message) != 0 { 2009 errorMessage = message 2010 } 2011 2012 switch { 2013 case strings.EqualFold("BadRequestException", errorCode): 2014 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2015 2016 case strings.EqualFold("ConflictException", errorCode): 2017 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2018 2019 case strings.EqualFold("ForbiddenException", errorCode): 2020 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 2021 2022 case strings.EqualFold("InternalServerErrorException", errorCode): 2023 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2024 2025 case strings.EqualFold("NotFoundException", errorCode): 2026 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 2027 2028 case strings.EqualFold("TooManyRequestsException", errorCode): 2029 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2030 2031 default: 2032 genericError := &smithy.GenericAPIError{ 2033 Code: errorCode, 2034 Message: errorMessage, 2035 } 2036 return genericError 2037 2038 } 2039} 2040 2041func awsRestjson1_deserializeOpDocumentGetQueueOutput(v **GetQueueOutput, value interface{}) error { 2042 if v == nil { 2043 return fmt.Errorf("unexpected nil of type %T", v) 2044 } 2045 if value == nil { 2046 return nil 2047 } 2048 2049 shape, ok := value.(map[string]interface{}) 2050 if !ok { 2051 return fmt.Errorf("unexpected JSON type %v", value) 2052 } 2053 2054 var sv *GetQueueOutput 2055 if *v == nil { 2056 sv = &GetQueueOutput{} 2057 } else { 2058 sv = *v 2059 } 2060 2061 for key, value := range shape { 2062 switch key { 2063 case "queue": 2064 if err := awsRestjson1_deserializeDocumentQueue(&sv.Queue, value); err != nil { 2065 return err 2066 } 2067 2068 default: 2069 _, _ = key, value 2070 2071 } 2072 } 2073 *v = sv 2074 return nil 2075} 2076 2077type awsRestjson1_deserializeOpListJobs struct { 2078} 2079 2080func (*awsRestjson1_deserializeOpListJobs) ID() string { 2081 return "OperationDeserializer" 2082} 2083 2084func (m *awsRestjson1_deserializeOpListJobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2085 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2086) { 2087 out, metadata, err = next.HandleDeserialize(ctx, in) 2088 if err != nil { 2089 return out, metadata, err 2090 } 2091 2092 response, ok := out.RawResponse.(*smithyhttp.Response) 2093 if !ok { 2094 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2095 } 2096 2097 if response.StatusCode < 200 || response.StatusCode >= 300 { 2098 return out, metadata, awsRestjson1_deserializeOpErrorListJobs(response, &metadata) 2099 } 2100 output := &ListJobsOutput{} 2101 out.Result = output 2102 2103 var buff [1024]byte 2104 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2105 2106 body := io.TeeReader(response.Body, ringBuffer) 2107 2108 decoder := json.NewDecoder(body) 2109 decoder.UseNumber() 2110 var shape interface{} 2111 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2112 var snapshot bytes.Buffer 2113 io.Copy(&snapshot, ringBuffer) 2114 err = &smithy.DeserializationError{ 2115 Err: fmt.Errorf("failed to decode response body, %w", err), 2116 Snapshot: snapshot.Bytes(), 2117 } 2118 return out, metadata, err 2119 } 2120 2121 err = awsRestjson1_deserializeOpDocumentListJobsOutput(&output, shape) 2122 if err != nil { 2123 var snapshot bytes.Buffer 2124 io.Copy(&snapshot, ringBuffer) 2125 return out, metadata, &smithy.DeserializationError{ 2126 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2127 Snapshot: snapshot.Bytes(), 2128 } 2129 } 2130 2131 return out, metadata, err 2132} 2133 2134func awsRestjson1_deserializeOpErrorListJobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2135 var errorBuffer bytes.Buffer 2136 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2137 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2138 } 2139 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2140 2141 errorCode := "UnknownError" 2142 errorMessage := errorCode 2143 2144 code := response.Header.Get("X-Amzn-ErrorType") 2145 if len(code) != 0 { 2146 errorCode = restjson.SanitizeErrorCode(code) 2147 } 2148 2149 var buff [1024]byte 2150 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2151 2152 body := io.TeeReader(errorBody, ringBuffer) 2153 decoder := json.NewDecoder(body) 2154 decoder.UseNumber() 2155 code, message, err := restjson.GetErrorInfo(decoder) 2156 if err != nil { 2157 var snapshot bytes.Buffer 2158 io.Copy(&snapshot, ringBuffer) 2159 err = &smithy.DeserializationError{ 2160 Err: fmt.Errorf("failed to decode response body, %w", err), 2161 Snapshot: snapshot.Bytes(), 2162 } 2163 return err 2164 } 2165 2166 errorBody.Seek(0, io.SeekStart) 2167 if len(code) != 0 { 2168 errorCode = restjson.SanitizeErrorCode(code) 2169 } 2170 if len(message) != 0 { 2171 errorMessage = message 2172 } 2173 2174 switch { 2175 case strings.EqualFold("BadRequestException", errorCode): 2176 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2177 2178 case strings.EqualFold("ConflictException", errorCode): 2179 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2180 2181 case strings.EqualFold("ForbiddenException", errorCode): 2182 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 2183 2184 case strings.EqualFold("InternalServerErrorException", errorCode): 2185 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2186 2187 case strings.EqualFold("NotFoundException", errorCode): 2188 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 2189 2190 case strings.EqualFold("TooManyRequestsException", errorCode): 2191 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2192 2193 default: 2194 genericError := &smithy.GenericAPIError{ 2195 Code: errorCode, 2196 Message: errorMessage, 2197 } 2198 return genericError 2199 2200 } 2201} 2202 2203func awsRestjson1_deserializeOpDocumentListJobsOutput(v **ListJobsOutput, value interface{}) error { 2204 if v == nil { 2205 return fmt.Errorf("unexpected nil of type %T", v) 2206 } 2207 if value == nil { 2208 return nil 2209 } 2210 2211 shape, ok := value.(map[string]interface{}) 2212 if !ok { 2213 return fmt.Errorf("unexpected JSON type %v", value) 2214 } 2215 2216 var sv *ListJobsOutput 2217 if *v == nil { 2218 sv = &ListJobsOutput{} 2219 } else { 2220 sv = *v 2221 } 2222 2223 for key, value := range shape { 2224 switch key { 2225 case "jobs": 2226 if err := awsRestjson1_deserializeDocument__listOfJob(&sv.Jobs, value); err != nil { 2227 return err 2228 } 2229 2230 case "nextToken": 2231 if value != nil { 2232 jtv, ok := value.(string) 2233 if !ok { 2234 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 2235 } 2236 sv.NextToken = ptr.String(jtv) 2237 } 2238 2239 default: 2240 _, _ = key, value 2241 2242 } 2243 } 2244 *v = sv 2245 return nil 2246} 2247 2248type awsRestjson1_deserializeOpListJobTemplates struct { 2249} 2250 2251func (*awsRestjson1_deserializeOpListJobTemplates) ID() string { 2252 return "OperationDeserializer" 2253} 2254 2255func (m *awsRestjson1_deserializeOpListJobTemplates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2256 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2257) { 2258 out, metadata, err = next.HandleDeserialize(ctx, in) 2259 if err != nil { 2260 return out, metadata, err 2261 } 2262 2263 response, ok := out.RawResponse.(*smithyhttp.Response) 2264 if !ok { 2265 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2266 } 2267 2268 if response.StatusCode < 200 || response.StatusCode >= 300 { 2269 return out, metadata, awsRestjson1_deserializeOpErrorListJobTemplates(response, &metadata) 2270 } 2271 output := &ListJobTemplatesOutput{} 2272 out.Result = output 2273 2274 var buff [1024]byte 2275 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2276 2277 body := io.TeeReader(response.Body, ringBuffer) 2278 2279 decoder := json.NewDecoder(body) 2280 decoder.UseNumber() 2281 var shape interface{} 2282 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2283 var snapshot bytes.Buffer 2284 io.Copy(&snapshot, ringBuffer) 2285 err = &smithy.DeserializationError{ 2286 Err: fmt.Errorf("failed to decode response body, %w", err), 2287 Snapshot: snapshot.Bytes(), 2288 } 2289 return out, metadata, err 2290 } 2291 2292 err = awsRestjson1_deserializeOpDocumentListJobTemplatesOutput(&output, shape) 2293 if err != nil { 2294 var snapshot bytes.Buffer 2295 io.Copy(&snapshot, ringBuffer) 2296 return out, metadata, &smithy.DeserializationError{ 2297 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2298 Snapshot: snapshot.Bytes(), 2299 } 2300 } 2301 2302 return out, metadata, err 2303} 2304 2305func awsRestjson1_deserializeOpErrorListJobTemplates(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2306 var errorBuffer bytes.Buffer 2307 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2308 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2309 } 2310 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2311 2312 errorCode := "UnknownError" 2313 errorMessage := errorCode 2314 2315 code := response.Header.Get("X-Amzn-ErrorType") 2316 if len(code) != 0 { 2317 errorCode = restjson.SanitizeErrorCode(code) 2318 } 2319 2320 var buff [1024]byte 2321 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2322 2323 body := io.TeeReader(errorBody, ringBuffer) 2324 decoder := json.NewDecoder(body) 2325 decoder.UseNumber() 2326 code, message, err := restjson.GetErrorInfo(decoder) 2327 if err != nil { 2328 var snapshot bytes.Buffer 2329 io.Copy(&snapshot, ringBuffer) 2330 err = &smithy.DeserializationError{ 2331 Err: fmt.Errorf("failed to decode response body, %w", err), 2332 Snapshot: snapshot.Bytes(), 2333 } 2334 return err 2335 } 2336 2337 errorBody.Seek(0, io.SeekStart) 2338 if len(code) != 0 { 2339 errorCode = restjson.SanitizeErrorCode(code) 2340 } 2341 if len(message) != 0 { 2342 errorMessage = message 2343 } 2344 2345 switch { 2346 case strings.EqualFold("BadRequestException", errorCode): 2347 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2348 2349 case strings.EqualFold("ConflictException", errorCode): 2350 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2351 2352 case strings.EqualFold("ForbiddenException", errorCode): 2353 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 2354 2355 case strings.EqualFold("InternalServerErrorException", errorCode): 2356 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2357 2358 case strings.EqualFold("NotFoundException", errorCode): 2359 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 2360 2361 case strings.EqualFold("TooManyRequestsException", errorCode): 2362 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2363 2364 default: 2365 genericError := &smithy.GenericAPIError{ 2366 Code: errorCode, 2367 Message: errorMessage, 2368 } 2369 return genericError 2370 2371 } 2372} 2373 2374func awsRestjson1_deserializeOpDocumentListJobTemplatesOutput(v **ListJobTemplatesOutput, value interface{}) error { 2375 if v == nil { 2376 return fmt.Errorf("unexpected nil of type %T", v) 2377 } 2378 if value == nil { 2379 return nil 2380 } 2381 2382 shape, ok := value.(map[string]interface{}) 2383 if !ok { 2384 return fmt.Errorf("unexpected JSON type %v", value) 2385 } 2386 2387 var sv *ListJobTemplatesOutput 2388 if *v == nil { 2389 sv = &ListJobTemplatesOutput{} 2390 } else { 2391 sv = *v 2392 } 2393 2394 for key, value := range shape { 2395 switch key { 2396 case "jobTemplates": 2397 if err := awsRestjson1_deserializeDocument__listOfJobTemplate(&sv.JobTemplates, value); err != nil { 2398 return err 2399 } 2400 2401 case "nextToken": 2402 if value != nil { 2403 jtv, ok := value.(string) 2404 if !ok { 2405 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 2406 } 2407 sv.NextToken = ptr.String(jtv) 2408 } 2409 2410 default: 2411 _, _ = key, value 2412 2413 } 2414 } 2415 *v = sv 2416 return nil 2417} 2418 2419type awsRestjson1_deserializeOpListPresets struct { 2420} 2421 2422func (*awsRestjson1_deserializeOpListPresets) ID() string { 2423 return "OperationDeserializer" 2424} 2425 2426func (m *awsRestjson1_deserializeOpListPresets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2427 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2428) { 2429 out, metadata, err = next.HandleDeserialize(ctx, in) 2430 if err != nil { 2431 return out, metadata, err 2432 } 2433 2434 response, ok := out.RawResponse.(*smithyhttp.Response) 2435 if !ok { 2436 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2437 } 2438 2439 if response.StatusCode < 200 || response.StatusCode >= 300 { 2440 return out, metadata, awsRestjson1_deserializeOpErrorListPresets(response, &metadata) 2441 } 2442 output := &ListPresetsOutput{} 2443 out.Result = output 2444 2445 var buff [1024]byte 2446 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2447 2448 body := io.TeeReader(response.Body, ringBuffer) 2449 2450 decoder := json.NewDecoder(body) 2451 decoder.UseNumber() 2452 var shape interface{} 2453 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2454 var snapshot bytes.Buffer 2455 io.Copy(&snapshot, ringBuffer) 2456 err = &smithy.DeserializationError{ 2457 Err: fmt.Errorf("failed to decode response body, %w", err), 2458 Snapshot: snapshot.Bytes(), 2459 } 2460 return out, metadata, err 2461 } 2462 2463 err = awsRestjson1_deserializeOpDocumentListPresetsOutput(&output, shape) 2464 if err != nil { 2465 var snapshot bytes.Buffer 2466 io.Copy(&snapshot, ringBuffer) 2467 return out, metadata, &smithy.DeserializationError{ 2468 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2469 Snapshot: snapshot.Bytes(), 2470 } 2471 } 2472 2473 return out, metadata, err 2474} 2475 2476func awsRestjson1_deserializeOpErrorListPresets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2477 var errorBuffer bytes.Buffer 2478 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2479 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2480 } 2481 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2482 2483 errorCode := "UnknownError" 2484 errorMessage := errorCode 2485 2486 code := response.Header.Get("X-Amzn-ErrorType") 2487 if len(code) != 0 { 2488 errorCode = restjson.SanitizeErrorCode(code) 2489 } 2490 2491 var buff [1024]byte 2492 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2493 2494 body := io.TeeReader(errorBody, ringBuffer) 2495 decoder := json.NewDecoder(body) 2496 decoder.UseNumber() 2497 code, message, err := restjson.GetErrorInfo(decoder) 2498 if err != nil { 2499 var snapshot bytes.Buffer 2500 io.Copy(&snapshot, ringBuffer) 2501 err = &smithy.DeserializationError{ 2502 Err: fmt.Errorf("failed to decode response body, %w", err), 2503 Snapshot: snapshot.Bytes(), 2504 } 2505 return err 2506 } 2507 2508 errorBody.Seek(0, io.SeekStart) 2509 if len(code) != 0 { 2510 errorCode = restjson.SanitizeErrorCode(code) 2511 } 2512 if len(message) != 0 { 2513 errorMessage = message 2514 } 2515 2516 switch { 2517 case strings.EqualFold("BadRequestException", errorCode): 2518 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2519 2520 case strings.EqualFold("ConflictException", errorCode): 2521 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2522 2523 case strings.EqualFold("ForbiddenException", errorCode): 2524 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 2525 2526 case strings.EqualFold("InternalServerErrorException", errorCode): 2527 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2528 2529 case strings.EqualFold("NotFoundException", errorCode): 2530 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 2531 2532 case strings.EqualFold("TooManyRequestsException", errorCode): 2533 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2534 2535 default: 2536 genericError := &smithy.GenericAPIError{ 2537 Code: errorCode, 2538 Message: errorMessage, 2539 } 2540 return genericError 2541 2542 } 2543} 2544 2545func awsRestjson1_deserializeOpDocumentListPresetsOutput(v **ListPresetsOutput, value interface{}) error { 2546 if v == nil { 2547 return fmt.Errorf("unexpected nil of type %T", v) 2548 } 2549 if value == nil { 2550 return nil 2551 } 2552 2553 shape, ok := value.(map[string]interface{}) 2554 if !ok { 2555 return fmt.Errorf("unexpected JSON type %v", value) 2556 } 2557 2558 var sv *ListPresetsOutput 2559 if *v == nil { 2560 sv = &ListPresetsOutput{} 2561 } else { 2562 sv = *v 2563 } 2564 2565 for key, value := range shape { 2566 switch key { 2567 case "nextToken": 2568 if value != nil { 2569 jtv, ok := value.(string) 2570 if !ok { 2571 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 2572 } 2573 sv.NextToken = ptr.String(jtv) 2574 } 2575 2576 case "presets": 2577 if err := awsRestjson1_deserializeDocument__listOfPreset(&sv.Presets, value); err != nil { 2578 return err 2579 } 2580 2581 default: 2582 _, _ = key, value 2583 2584 } 2585 } 2586 *v = sv 2587 return nil 2588} 2589 2590type awsRestjson1_deserializeOpListQueues struct { 2591} 2592 2593func (*awsRestjson1_deserializeOpListQueues) ID() string { 2594 return "OperationDeserializer" 2595} 2596 2597func (m *awsRestjson1_deserializeOpListQueues) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2598 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2599) { 2600 out, metadata, err = next.HandleDeserialize(ctx, in) 2601 if err != nil { 2602 return out, metadata, err 2603 } 2604 2605 response, ok := out.RawResponse.(*smithyhttp.Response) 2606 if !ok { 2607 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2608 } 2609 2610 if response.StatusCode < 200 || response.StatusCode >= 300 { 2611 return out, metadata, awsRestjson1_deserializeOpErrorListQueues(response, &metadata) 2612 } 2613 output := &ListQueuesOutput{} 2614 out.Result = output 2615 2616 var buff [1024]byte 2617 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2618 2619 body := io.TeeReader(response.Body, ringBuffer) 2620 2621 decoder := json.NewDecoder(body) 2622 decoder.UseNumber() 2623 var shape interface{} 2624 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2625 var snapshot bytes.Buffer 2626 io.Copy(&snapshot, ringBuffer) 2627 err = &smithy.DeserializationError{ 2628 Err: fmt.Errorf("failed to decode response body, %w", err), 2629 Snapshot: snapshot.Bytes(), 2630 } 2631 return out, metadata, err 2632 } 2633 2634 err = awsRestjson1_deserializeOpDocumentListQueuesOutput(&output, shape) 2635 if err != nil { 2636 var snapshot bytes.Buffer 2637 io.Copy(&snapshot, ringBuffer) 2638 return out, metadata, &smithy.DeserializationError{ 2639 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2640 Snapshot: snapshot.Bytes(), 2641 } 2642 } 2643 2644 return out, metadata, err 2645} 2646 2647func awsRestjson1_deserializeOpErrorListQueues(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2648 var errorBuffer bytes.Buffer 2649 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2650 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2651 } 2652 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2653 2654 errorCode := "UnknownError" 2655 errorMessage := errorCode 2656 2657 code := response.Header.Get("X-Amzn-ErrorType") 2658 if len(code) != 0 { 2659 errorCode = restjson.SanitizeErrorCode(code) 2660 } 2661 2662 var buff [1024]byte 2663 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2664 2665 body := io.TeeReader(errorBody, ringBuffer) 2666 decoder := json.NewDecoder(body) 2667 decoder.UseNumber() 2668 code, message, err := restjson.GetErrorInfo(decoder) 2669 if err != nil { 2670 var snapshot bytes.Buffer 2671 io.Copy(&snapshot, ringBuffer) 2672 err = &smithy.DeserializationError{ 2673 Err: fmt.Errorf("failed to decode response body, %w", err), 2674 Snapshot: snapshot.Bytes(), 2675 } 2676 return err 2677 } 2678 2679 errorBody.Seek(0, io.SeekStart) 2680 if len(code) != 0 { 2681 errorCode = restjson.SanitizeErrorCode(code) 2682 } 2683 if len(message) != 0 { 2684 errorMessage = message 2685 } 2686 2687 switch { 2688 case strings.EqualFold("BadRequestException", errorCode): 2689 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2690 2691 case strings.EqualFold("ConflictException", errorCode): 2692 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2693 2694 case strings.EqualFold("ForbiddenException", errorCode): 2695 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 2696 2697 case strings.EqualFold("InternalServerErrorException", errorCode): 2698 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2699 2700 case strings.EqualFold("NotFoundException", errorCode): 2701 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 2702 2703 case strings.EqualFold("TooManyRequestsException", errorCode): 2704 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2705 2706 default: 2707 genericError := &smithy.GenericAPIError{ 2708 Code: errorCode, 2709 Message: errorMessage, 2710 } 2711 return genericError 2712 2713 } 2714} 2715 2716func awsRestjson1_deserializeOpDocumentListQueuesOutput(v **ListQueuesOutput, value interface{}) error { 2717 if v == nil { 2718 return fmt.Errorf("unexpected nil of type %T", v) 2719 } 2720 if value == nil { 2721 return nil 2722 } 2723 2724 shape, ok := value.(map[string]interface{}) 2725 if !ok { 2726 return fmt.Errorf("unexpected JSON type %v", value) 2727 } 2728 2729 var sv *ListQueuesOutput 2730 if *v == nil { 2731 sv = &ListQueuesOutput{} 2732 } else { 2733 sv = *v 2734 } 2735 2736 for key, value := range shape { 2737 switch key { 2738 case "nextToken": 2739 if value != nil { 2740 jtv, ok := value.(string) 2741 if !ok { 2742 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 2743 } 2744 sv.NextToken = ptr.String(jtv) 2745 } 2746 2747 case "queues": 2748 if err := awsRestjson1_deserializeDocument__listOfQueue(&sv.Queues, value); err != nil { 2749 return err 2750 } 2751 2752 default: 2753 _, _ = key, value 2754 2755 } 2756 } 2757 *v = sv 2758 return nil 2759} 2760 2761type awsRestjson1_deserializeOpListTagsForResource struct { 2762} 2763 2764func (*awsRestjson1_deserializeOpListTagsForResource) ID() string { 2765 return "OperationDeserializer" 2766} 2767 2768func (m *awsRestjson1_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2769 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2770) { 2771 out, metadata, err = next.HandleDeserialize(ctx, in) 2772 if err != nil { 2773 return out, metadata, err 2774 } 2775 2776 response, ok := out.RawResponse.(*smithyhttp.Response) 2777 if !ok { 2778 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2779 } 2780 2781 if response.StatusCode < 200 || response.StatusCode >= 300 { 2782 return out, metadata, awsRestjson1_deserializeOpErrorListTagsForResource(response, &metadata) 2783 } 2784 output := &ListTagsForResourceOutput{} 2785 out.Result = output 2786 2787 var buff [1024]byte 2788 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2789 2790 body := io.TeeReader(response.Body, ringBuffer) 2791 2792 decoder := json.NewDecoder(body) 2793 decoder.UseNumber() 2794 var shape interface{} 2795 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2796 var snapshot bytes.Buffer 2797 io.Copy(&snapshot, ringBuffer) 2798 err = &smithy.DeserializationError{ 2799 Err: fmt.Errorf("failed to decode response body, %w", err), 2800 Snapshot: snapshot.Bytes(), 2801 } 2802 return out, metadata, err 2803 } 2804 2805 err = awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 2806 if err != nil { 2807 var snapshot bytes.Buffer 2808 io.Copy(&snapshot, ringBuffer) 2809 return out, metadata, &smithy.DeserializationError{ 2810 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2811 Snapshot: snapshot.Bytes(), 2812 } 2813 } 2814 2815 return out, metadata, err 2816} 2817 2818func awsRestjson1_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2819 var errorBuffer bytes.Buffer 2820 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2821 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2822 } 2823 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2824 2825 errorCode := "UnknownError" 2826 errorMessage := errorCode 2827 2828 code := response.Header.Get("X-Amzn-ErrorType") 2829 if len(code) != 0 { 2830 errorCode = restjson.SanitizeErrorCode(code) 2831 } 2832 2833 var buff [1024]byte 2834 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2835 2836 body := io.TeeReader(errorBody, ringBuffer) 2837 decoder := json.NewDecoder(body) 2838 decoder.UseNumber() 2839 code, message, err := restjson.GetErrorInfo(decoder) 2840 if err != nil { 2841 var snapshot bytes.Buffer 2842 io.Copy(&snapshot, ringBuffer) 2843 err = &smithy.DeserializationError{ 2844 Err: fmt.Errorf("failed to decode response body, %w", err), 2845 Snapshot: snapshot.Bytes(), 2846 } 2847 return err 2848 } 2849 2850 errorBody.Seek(0, io.SeekStart) 2851 if len(code) != 0 { 2852 errorCode = restjson.SanitizeErrorCode(code) 2853 } 2854 if len(message) != 0 { 2855 errorMessage = message 2856 } 2857 2858 switch { 2859 case strings.EqualFold("BadRequestException", errorCode): 2860 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2861 2862 case strings.EqualFold("ConflictException", errorCode): 2863 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2864 2865 case strings.EqualFold("ForbiddenException", errorCode): 2866 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 2867 2868 case strings.EqualFold("InternalServerErrorException", errorCode): 2869 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2870 2871 case strings.EqualFold("NotFoundException", errorCode): 2872 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 2873 2874 case strings.EqualFold("TooManyRequestsException", errorCode): 2875 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2876 2877 default: 2878 genericError := &smithy.GenericAPIError{ 2879 Code: errorCode, 2880 Message: errorMessage, 2881 } 2882 return genericError 2883 2884 } 2885} 2886 2887func awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 2888 if v == nil { 2889 return fmt.Errorf("unexpected nil of type %T", v) 2890 } 2891 if value == nil { 2892 return nil 2893 } 2894 2895 shape, ok := value.(map[string]interface{}) 2896 if !ok { 2897 return fmt.Errorf("unexpected JSON type %v", value) 2898 } 2899 2900 var sv *ListTagsForResourceOutput 2901 if *v == nil { 2902 sv = &ListTagsForResourceOutput{} 2903 } else { 2904 sv = *v 2905 } 2906 2907 for key, value := range shape { 2908 switch key { 2909 case "resourceTags": 2910 if err := awsRestjson1_deserializeDocumentResourceTags(&sv.ResourceTags, value); err != nil { 2911 return err 2912 } 2913 2914 default: 2915 _, _ = key, value 2916 2917 } 2918 } 2919 *v = sv 2920 return nil 2921} 2922 2923type awsRestjson1_deserializeOpTagResource struct { 2924} 2925 2926func (*awsRestjson1_deserializeOpTagResource) ID() string { 2927 return "OperationDeserializer" 2928} 2929 2930func (m *awsRestjson1_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2931 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2932) { 2933 out, metadata, err = next.HandleDeserialize(ctx, in) 2934 if err != nil { 2935 return out, metadata, err 2936 } 2937 2938 response, ok := out.RawResponse.(*smithyhttp.Response) 2939 if !ok { 2940 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2941 } 2942 2943 if response.StatusCode < 200 || response.StatusCode >= 300 { 2944 return out, metadata, awsRestjson1_deserializeOpErrorTagResource(response, &metadata) 2945 } 2946 output := &TagResourceOutput{} 2947 out.Result = output 2948 2949 return out, metadata, err 2950} 2951 2952func awsRestjson1_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2953 var errorBuffer bytes.Buffer 2954 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2955 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2956 } 2957 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2958 2959 errorCode := "UnknownError" 2960 errorMessage := errorCode 2961 2962 code := response.Header.Get("X-Amzn-ErrorType") 2963 if len(code) != 0 { 2964 errorCode = restjson.SanitizeErrorCode(code) 2965 } 2966 2967 var buff [1024]byte 2968 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2969 2970 body := io.TeeReader(errorBody, ringBuffer) 2971 decoder := json.NewDecoder(body) 2972 decoder.UseNumber() 2973 code, message, err := restjson.GetErrorInfo(decoder) 2974 if err != nil { 2975 var snapshot bytes.Buffer 2976 io.Copy(&snapshot, ringBuffer) 2977 err = &smithy.DeserializationError{ 2978 Err: fmt.Errorf("failed to decode response body, %w", err), 2979 Snapshot: snapshot.Bytes(), 2980 } 2981 return err 2982 } 2983 2984 errorBody.Seek(0, io.SeekStart) 2985 if len(code) != 0 { 2986 errorCode = restjson.SanitizeErrorCode(code) 2987 } 2988 if len(message) != 0 { 2989 errorMessage = message 2990 } 2991 2992 switch { 2993 case strings.EqualFold("BadRequestException", errorCode): 2994 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2995 2996 case strings.EqualFold("ConflictException", errorCode): 2997 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 2998 2999 case strings.EqualFold("ForbiddenException", errorCode): 3000 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 3001 3002 case strings.EqualFold("InternalServerErrorException", errorCode): 3003 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3004 3005 case strings.EqualFold("NotFoundException", errorCode): 3006 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 3007 3008 case strings.EqualFold("TooManyRequestsException", errorCode): 3009 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3010 3011 default: 3012 genericError := &smithy.GenericAPIError{ 3013 Code: errorCode, 3014 Message: errorMessage, 3015 } 3016 return genericError 3017 3018 } 3019} 3020 3021type awsRestjson1_deserializeOpUntagResource struct { 3022} 3023 3024func (*awsRestjson1_deserializeOpUntagResource) ID() string { 3025 return "OperationDeserializer" 3026} 3027 3028func (m *awsRestjson1_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3029 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3030) { 3031 out, metadata, err = next.HandleDeserialize(ctx, in) 3032 if err != nil { 3033 return out, metadata, err 3034 } 3035 3036 response, ok := out.RawResponse.(*smithyhttp.Response) 3037 if !ok { 3038 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3039 } 3040 3041 if response.StatusCode < 200 || response.StatusCode >= 300 { 3042 return out, metadata, awsRestjson1_deserializeOpErrorUntagResource(response, &metadata) 3043 } 3044 output := &UntagResourceOutput{} 3045 out.Result = output 3046 3047 return out, metadata, err 3048} 3049 3050func awsRestjson1_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3051 var errorBuffer bytes.Buffer 3052 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3053 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3054 } 3055 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3056 3057 errorCode := "UnknownError" 3058 errorMessage := errorCode 3059 3060 code := response.Header.Get("X-Amzn-ErrorType") 3061 if len(code) != 0 { 3062 errorCode = restjson.SanitizeErrorCode(code) 3063 } 3064 3065 var buff [1024]byte 3066 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3067 3068 body := io.TeeReader(errorBody, ringBuffer) 3069 decoder := json.NewDecoder(body) 3070 decoder.UseNumber() 3071 code, message, err := restjson.GetErrorInfo(decoder) 3072 if err != nil { 3073 var snapshot bytes.Buffer 3074 io.Copy(&snapshot, ringBuffer) 3075 err = &smithy.DeserializationError{ 3076 Err: fmt.Errorf("failed to decode response body, %w", err), 3077 Snapshot: snapshot.Bytes(), 3078 } 3079 return err 3080 } 3081 3082 errorBody.Seek(0, io.SeekStart) 3083 if len(code) != 0 { 3084 errorCode = restjson.SanitizeErrorCode(code) 3085 } 3086 if len(message) != 0 { 3087 errorMessage = message 3088 } 3089 3090 switch { 3091 case strings.EqualFold("BadRequestException", errorCode): 3092 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3093 3094 case strings.EqualFold("ConflictException", errorCode): 3095 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3096 3097 case strings.EqualFold("ForbiddenException", errorCode): 3098 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 3099 3100 case strings.EqualFold("InternalServerErrorException", errorCode): 3101 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3102 3103 case strings.EqualFold("NotFoundException", errorCode): 3104 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 3105 3106 case strings.EqualFold("TooManyRequestsException", errorCode): 3107 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3108 3109 default: 3110 genericError := &smithy.GenericAPIError{ 3111 Code: errorCode, 3112 Message: errorMessage, 3113 } 3114 return genericError 3115 3116 } 3117} 3118 3119type awsRestjson1_deserializeOpUpdateJobTemplate struct { 3120} 3121 3122func (*awsRestjson1_deserializeOpUpdateJobTemplate) ID() string { 3123 return "OperationDeserializer" 3124} 3125 3126func (m *awsRestjson1_deserializeOpUpdateJobTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3127 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3128) { 3129 out, metadata, err = next.HandleDeserialize(ctx, in) 3130 if err != nil { 3131 return out, metadata, err 3132 } 3133 3134 response, ok := out.RawResponse.(*smithyhttp.Response) 3135 if !ok { 3136 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3137 } 3138 3139 if response.StatusCode < 200 || response.StatusCode >= 300 { 3140 return out, metadata, awsRestjson1_deserializeOpErrorUpdateJobTemplate(response, &metadata) 3141 } 3142 output := &UpdateJobTemplateOutput{} 3143 out.Result = output 3144 3145 var buff [1024]byte 3146 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3147 3148 body := io.TeeReader(response.Body, ringBuffer) 3149 3150 decoder := json.NewDecoder(body) 3151 decoder.UseNumber() 3152 var shape interface{} 3153 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3154 var snapshot bytes.Buffer 3155 io.Copy(&snapshot, ringBuffer) 3156 err = &smithy.DeserializationError{ 3157 Err: fmt.Errorf("failed to decode response body, %w", err), 3158 Snapshot: snapshot.Bytes(), 3159 } 3160 return out, metadata, err 3161 } 3162 3163 err = awsRestjson1_deserializeOpDocumentUpdateJobTemplateOutput(&output, shape) 3164 if err != nil { 3165 var snapshot bytes.Buffer 3166 io.Copy(&snapshot, ringBuffer) 3167 return out, metadata, &smithy.DeserializationError{ 3168 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3169 Snapshot: snapshot.Bytes(), 3170 } 3171 } 3172 3173 return out, metadata, err 3174} 3175 3176func awsRestjson1_deserializeOpErrorUpdateJobTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3177 var errorBuffer bytes.Buffer 3178 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3179 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3180 } 3181 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3182 3183 errorCode := "UnknownError" 3184 errorMessage := errorCode 3185 3186 code := response.Header.Get("X-Amzn-ErrorType") 3187 if len(code) != 0 { 3188 errorCode = restjson.SanitizeErrorCode(code) 3189 } 3190 3191 var buff [1024]byte 3192 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3193 3194 body := io.TeeReader(errorBody, ringBuffer) 3195 decoder := json.NewDecoder(body) 3196 decoder.UseNumber() 3197 code, message, err := restjson.GetErrorInfo(decoder) 3198 if err != nil { 3199 var snapshot bytes.Buffer 3200 io.Copy(&snapshot, ringBuffer) 3201 err = &smithy.DeserializationError{ 3202 Err: fmt.Errorf("failed to decode response body, %w", err), 3203 Snapshot: snapshot.Bytes(), 3204 } 3205 return err 3206 } 3207 3208 errorBody.Seek(0, io.SeekStart) 3209 if len(code) != 0 { 3210 errorCode = restjson.SanitizeErrorCode(code) 3211 } 3212 if len(message) != 0 { 3213 errorMessage = message 3214 } 3215 3216 switch { 3217 case strings.EqualFold("BadRequestException", errorCode): 3218 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3219 3220 case strings.EqualFold("ConflictException", errorCode): 3221 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3222 3223 case strings.EqualFold("ForbiddenException", errorCode): 3224 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 3225 3226 case strings.EqualFold("InternalServerErrorException", errorCode): 3227 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3228 3229 case strings.EqualFold("NotFoundException", errorCode): 3230 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 3231 3232 case strings.EqualFold("TooManyRequestsException", errorCode): 3233 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3234 3235 default: 3236 genericError := &smithy.GenericAPIError{ 3237 Code: errorCode, 3238 Message: errorMessage, 3239 } 3240 return genericError 3241 3242 } 3243} 3244 3245func awsRestjson1_deserializeOpDocumentUpdateJobTemplateOutput(v **UpdateJobTemplateOutput, value interface{}) error { 3246 if v == nil { 3247 return fmt.Errorf("unexpected nil of type %T", v) 3248 } 3249 if value == nil { 3250 return nil 3251 } 3252 3253 shape, ok := value.(map[string]interface{}) 3254 if !ok { 3255 return fmt.Errorf("unexpected JSON type %v", value) 3256 } 3257 3258 var sv *UpdateJobTemplateOutput 3259 if *v == nil { 3260 sv = &UpdateJobTemplateOutput{} 3261 } else { 3262 sv = *v 3263 } 3264 3265 for key, value := range shape { 3266 switch key { 3267 case "jobTemplate": 3268 if err := awsRestjson1_deserializeDocumentJobTemplate(&sv.JobTemplate, value); err != nil { 3269 return err 3270 } 3271 3272 default: 3273 _, _ = key, value 3274 3275 } 3276 } 3277 *v = sv 3278 return nil 3279} 3280 3281type awsRestjson1_deserializeOpUpdatePreset struct { 3282} 3283 3284func (*awsRestjson1_deserializeOpUpdatePreset) ID() string { 3285 return "OperationDeserializer" 3286} 3287 3288func (m *awsRestjson1_deserializeOpUpdatePreset) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3289 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3290) { 3291 out, metadata, err = next.HandleDeserialize(ctx, in) 3292 if err != nil { 3293 return out, metadata, err 3294 } 3295 3296 response, ok := out.RawResponse.(*smithyhttp.Response) 3297 if !ok { 3298 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3299 } 3300 3301 if response.StatusCode < 200 || response.StatusCode >= 300 { 3302 return out, metadata, awsRestjson1_deserializeOpErrorUpdatePreset(response, &metadata) 3303 } 3304 output := &UpdatePresetOutput{} 3305 out.Result = output 3306 3307 var buff [1024]byte 3308 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3309 3310 body := io.TeeReader(response.Body, ringBuffer) 3311 3312 decoder := json.NewDecoder(body) 3313 decoder.UseNumber() 3314 var shape interface{} 3315 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3316 var snapshot bytes.Buffer 3317 io.Copy(&snapshot, ringBuffer) 3318 err = &smithy.DeserializationError{ 3319 Err: fmt.Errorf("failed to decode response body, %w", err), 3320 Snapshot: snapshot.Bytes(), 3321 } 3322 return out, metadata, err 3323 } 3324 3325 err = awsRestjson1_deserializeOpDocumentUpdatePresetOutput(&output, shape) 3326 if err != nil { 3327 var snapshot bytes.Buffer 3328 io.Copy(&snapshot, ringBuffer) 3329 return out, metadata, &smithy.DeserializationError{ 3330 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3331 Snapshot: snapshot.Bytes(), 3332 } 3333 } 3334 3335 return out, metadata, err 3336} 3337 3338func awsRestjson1_deserializeOpErrorUpdatePreset(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3339 var errorBuffer bytes.Buffer 3340 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3341 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3342 } 3343 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3344 3345 errorCode := "UnknownError" 3346 errorMessage := errorCode 3347 3348 code := response.Header.Get("X-Amzn-ErrorType") 3349 if len(code) != 0 { 3350 errorCode = restjson.SanitizeErrorCode(code) 3351 } 3352 3353 var buff [1024]byte 3354 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3355 3356 body := io.TeeReader(errorBody, ringBuffer) 3357 decoder := json.NewDecoder(body) 3358 decoder.UseNumber() 3359 code, message, err := restjson.GetErrorInfo(decoder) 3360 if err != nil { 3361 var snapshot bytes.Buffer 3362 io.Copy(&snapshot, ringBuffer) 3363 err = &smithy.DeserializationError{ 3364 Err: fmt.Errorf("failed to decode response body, %w", err), 3365 Snapshot: snapshot.Bytes(), 3366 } 3367 return err 3368 } 3369 3370 errorBody.Seek(0, io.SeekStart) 3371 if len(code) != 0 { 3372 errorCode = restjson.SanitizeErrorCode(code) 3373 } 3374 if len(message) != 0 { 3375 errorMessage = message 3376 } 3377 3378 switch { 3379 case strings.EqualFold("BadRequestException", errorCode): 3380 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3381 3382 case strings.EqualFold("ConflictException", errorCode): 3383 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3384 3385 case strings.EqualFold("ForbiddenException", errorCode): 3386 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 3387 3388 case strings.EqualFold("InternalServerErrorException", errorCode): 3389 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3390 3391 case strings.EqualFold("NotFoundException", errorCode): 3392 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 3393 3394 case strings.EqualFold("TooManyRequestsException", errorCode): 3395 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3396 3397 default: 3398 genericError := &smithy.GenericAPIError{ 3399 Code: errorCode, 3400 Message: errorMessage, 3401 } 3402 return genericError 3403 3404 } 3405} 3406 3407func awsRestjson1_deserializeOpDocumentUpdatePresetOutput(v **UpdatePresetOutput, value interface{}) error { 3408 if v == nil { 3409 return fmt.Errorf("unexpected nil of type %T", v) 3410 } 3411 if value == nil { 3412 return nil 3413 } 3414 3415 shape, ok := value.(map[string]interface{}) 3416 if !ok { 3417 return fmt.Errorf("unexpected JSON type %v", value) 3418 } 3419 3420 var sv *UpdatePresetOutput 3421 if *v == nil { 3422 sv = &UpdatePresetOutput{} 3423 } else { 3424 sv = *v 3425 } 3426 3427 for key, value := range shape { 3428 switch key { 3429 case "preset": 3430 if err := awsRestjson1_deserializeDocumentPreset(&sv.Preset, value); err != nil { 3431 return err 3432 } 3433 3434 default: 3435 _, _ = key, value 3436 3437 } 3438 } 3439 *v = sv 3440 return nil 3441} 3442 3443type awsRestjson1_deserializeOpUpdateQueue struct { 3444} 3445 3446func (*awsRestjson1_deserializeOpUpdateQueue) ID() string { 3447 return "OperationDeserializer" 3448} 3449 3450func (m *awsRestjson1_deserializeOpUpdateQueue) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3451 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3452) { 3453 out, metadata, err = next.HandleDeserialize(ctx, in) 3454 if err != nil { 3455 return out, metadata, err 3456 } 3457 3458 response, ok := out.RawResponse.(*smithyhttp.Response) 3459 if !ok { 3460 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3461 } 3462 3463 if response.StatusCode < 200 || response.StatusCode >= 300 { 3464 return out, metadata, awsRestjson1_deserializeOpErrorUpdateQueue(response, &metadata) 3465 } 3466 output := &UpdateQueueOutput{} 3467 out.Result = output 3468 3469 var buff [1024]byte 3470 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3471 3472 body := io.TeeReader(response.Body, ringBuffer) 3473 3474 decoder := json.NewDecoder(body) 3475 decoder.UseNumber() 3476 var shape interface{} 3477 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3478 var snapshot bytes.Buffer 3479 io.Copy(&snapshot, ringBuffer) 3480 err = &smithy.DeserializationError{ 3481 Err: fmt.Errorf("failed to decode response body, %w", err), 3482 Snapshot: snapshot.Bytes(), 3483 } 3484 return out, metadata, err 3485 } 3486 3487 err = awsRestjson1_deserializeOpDocumentUpdateQueueOutput(&output, shape) 3488 if err != nil { 3489 var snapshot bytes.Buffer 3490 io.Copy(&snapshot, ringBuffer) 3491 return out, metadata, &smithy.DeserializationError{ 3492 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3493 Snapshot: snapshot.Bytes(), 3494 } 3495 } 3496 3497 return out, metadata, err 3498} 3499 3500func awsRestjson1_deserializeOpErrorUpdateQueue(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3501 var errorBuffer bytes.Buffer 3502 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3503 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3504 } 3505 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3506 3507 errorCode := "UnknownError" 3508 errorMessage := errorCode 3509 3510 code := response.Header.Get("X-Amzn-ErrorType") 3511 if len(code) != 0 { 3512 errorCode = restjson.SanitizeErrorCode(code) 3513 } 3514 3515 var buff [1024]byte 3516 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3517 3518 body := io.TeeReader(errorBody, ringBuffer) 3519 decoder := json.NewDecoder(body) 3520 decoder.UseNumber() 3521 code, message, err := restjson.GetErrorInfo(decoder) 3522 if err != nil { 3523 var snapshot bytes.Buffer 3524 io.Copy(&snapshot, ringBuffer) 3525 err = &smithy.DeserializationError{ 3526 Err: fmt.Errorf("failed to decode response body, %w", err), 3527 Snapshot: snapshot.Bytes(), 3528 } 3529 return err 3530 } 3531 3532 errorBody.Seek(0, io.SeekStart) 3533 if len(code) != 0 { 3534 errorCode = restjson.SanitizeErrorCode(code) 3535 } 3536 if len(message) != 0 { 3537 errorMessage = message 3538 } 3539 3540 switch { 3541 case strings.EqualFold("BadRequestException", errorCode): 3542 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3543 3544 case strings.EqualFold("ConflictException", errorCode): 3545 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 3546 3547 case strings.EqualFold("ForbiddenException", errorCode): 3548 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 3549 3550 case strings.EqualFold("InternalServerErrorException", errorCode): 3551 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3552 3553 case strings.EqualFold("NotFoundException", errorCode): 3554 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 3555 3556 case strings.EqualFold("TooManyRequestsException", errorCode): 3557 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3558 3559 default: 3560 genericError := &smithy.GenericAPIError{ 3561 Code: errorCode, 3562 Message: errorMessage, 3563 } 3564 return genericError 3565 3566 } 3567} 3568 3569func awsRestjson1_deserializeOpDocumentUpdateQueueOutput(v **UpdateQueueOutput, value interface{}) error { 3570 if v == nil { 3571 return fmt.Errorf("unexpected nil of type %T", v) 3572 } 3573 if value == nil { 3574 return nil 3575 } 3576 3577 shape, ok := value.(map[string]interface{}) 3578 if !ok { 3579 return fmt.Errorf("unexpected JSON type %v", value) 3580 } 3581 3582 var sv *UpdateQueueOutput 3583 if *v == nil { 3584 sv = &UpdateQueueOutput{} 3585 } else { 3586 sv = *v 3587 } 3588 3589 for key, value := range shape { 3590 switch key { 3591 case "queue": 3592 if err := awsRestjson1_deserializeDocumentQueue(&sv.Queue, value); err != nil { 3593 return err 3594 } 3595 3596 default: 3597 _, _ = key, value 3598 3599 } 3600 } 3601 *v = sv 3602 return nil 3603} 3604 3605func awsRestjson1_deserializeErrorBadRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3606 output := &types.BadRequestException{} 3607 var buff [1024]byte 3608 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3609 3610 body := io.TeeReader(errorBody, ringBuffer) 3611 decoder := json.NewDecoder(body) 3612 decoder.UseNumber() 3613 var shape interface{} 3614 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3615 var snapshot bytes.Buffer 3616 io.Copy(&snapshot, ringBuffer) 3617 err = &smithy.DeserializationError{ 3618 Err: fmt.Errorf("failed to decode response body, %w", err), 3619 Snapshot: snapshot.Bytes(), 3620 } 3621 return err 3622 } 3623 3624 err := awsRestjson1_deserializeDocumentBadRequestException(&output, shape) 3625 3626 if err != nil { 3627 var snapshot bytes.Buffer 3628 io.Copy(&snapshot, ringBuffer) 3629 err = &smithy.DeserializationError{ 3630 Err: fmt.Errorf("failed to decode response body, %w", err), 3631 Snapshot: snapshot.Bytes(), 3632 } 3633 return err 3634 } 3635 3636 errorBody.Seek(0, io.SeekStart) 3637 3638 return output 3639} 3640 3641func awsRestjson1_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3642 output := &types.ConflictException{} 3643 var buff [1024]byte 3644 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3645 3646 body := io.TeeReader(errorBody, ringBuffer) 3647 decoder := json.NewDecoder(body) 3648 decoder.UseNumber() 3649 var shape interface{} 3650 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3651 var snapshot bytes.Buffer 3652 io.Copy(&snapshot, ringBuffer) 3653 err = &smithy.DeserializationError{ 3654 Err: fmt.Errorf("failed to decode response body, %w", err), 3655 Snapshot: snapshot.Bytes(), 3656 } 3657 return err 3658 } 3659 3660 err := awsRestjson1_deserializeDocumentConflictException(&output, shape) 3661 3662 if err != nil { 3663 var snapshot bytes.Buffer 3664 io.Copy(&snapshot, ringBuffer) 3665 err = &smithy.DeserializationError{ 3666 Err: fmt.Errorf("failed to decode response body, %w", err), 3667 Snapshot: snapshot.Bytes(), 3668 } 3669 return err 3670 } 3671 3672 errorBody.Seek(0, io.SeekStart) 3673 3674 return output 3675} 3676 3677func awsRestjson1_deserializeErrorForbiddenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3678 output := &types.ForbiddenException{} 3679 var buff [1024]byte 3680 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3681 3682 body := io.TeeReader(errorBody, ringBuffer) 3683 decoder := json.NewDecoder(body) 3684 decoder.UseNumber() 3685 var shape interface{} 3686 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3687 var snapshot bytes.Buffer 3688 io.Copy(&snapshot, ringBuffer) 3689 err = &smithy.DeserializationError{ 3690 Err: fmt.Errorf("failed to decode response body, %w", err), 3691 Snapshot: snapshot.Bytes(), 3692 } 3693 return err 3694 } 3695 3696 err := awsRestjson1_deserializeDocumentForbiddenException(&output, shape) 3697 3698 if err != nil { 3699 var snapshot bytes.Buffer 3700 io.Copy(&snapshot, ringBuffer) 3701 err = &smithy.DeserializationError{ 3702 Err: fmt.Errorf("failed to decode response body, %w", err), 3703 Snapshot: snapshot.Bytes(), 3704 } 3705 return err 3706 } 3707 3708 errorBody.Seek(0, io.SeekStart) 3709 3710 return output 3711} 3712 3713func awsRestjson1_deserializeErrorInternalServerErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3714 output := &types.InternalServerErrorException{} 3715 var buff [1024]byte 3716 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3717 3718 body := io.TeeReader(errorBody, ringBuffer) 3719 decoder := json.NewDecoder(body) 3720 decoder.UseNumber() 3721 var shape interface{} 3722 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3723 var snapshot bytes.Buffer 3724 io.Copy(&snapshot, ringBuffer) 3725 err = &smithy.DeserializationError{ 3726 Err: fmt.Errorf("failed to decode response body, %w", err), 3727 Snapshot: snapshot.Bytes(), 3728 } 3729 return err 3730 } 3731 3732 err := awsRestjson1_deserializeDocumentInternalServerErrorException(&output, shape) 3733 3734 if err != nil { 3735 var snapshot bytes.Buffer 3736 io.Copy(&snapshot, ringBuffer) 3737 err = &smithy.DeserializationError{ 3738 Err: fmt.Errorf("failed to decode response body, %w", err), 3739 Snapshot: snapshot.Bytes(), 3740 } 3741 return err 3742 } 3743 3744 errorBody.Seek(0, io.SeekStart) 3745 3746 return output 3747} 3748 3749func awsRestjson1_deserializeErrorNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3750 output := &types.NotFoundException{} 3751 var buff [1024]byte 3752 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3753 3754 body := io.TeeReader(errorBody, ringBuffer) 3755 decoder := json.NewDecoder(body) 3756 decoder.UseNumber() 3757 var shape interface{} 3758 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3759 var snapshot bytes.Buffer 3760 io.Copy(&snapshot, ringBuffer) 3761 err = &smithy.DeserializationError{ 3762 Err: fmt.Errorf("failed to decode response body, %w", err), 3763 Snapshot: snapshot.Bytes(), 3764 } 3765 return err 3766 } 3767 3768 err := awsRestjson1_deserializeDocumentNotFoundException(&output, shape) 3769 3770 if err != nil { 3771 var snapshot bytes.Buffer 3772 io.Copy(&snapshot, ringBuffer) 3773 err = &smithy.DeserializationError{ 3774 Err: fmt.Errorf("failed to decode response body, %w", err), 3775 Snapshot: snapshot.Bytes(), 3776 } 3777 return err 3778 } 3779 3780 errorBody.Seek(0, io.SeekStart) 3781 3782 return output 3783} 3784 3785func awsRestjson1_deserializeErrorTooManyRequestsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3786 output := &types.TooManyRequestsException{} 3787 var buff [1024]byte 3788 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3789 3790 body := io.TeeReader(errorBody, ringBuffer) 3791 decoder := json.NewDecoder(body) 3792 decoder.UseNumber() 3793 var shape interface{} 3794 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3795 var snapshot bytes.Buffer 3796 io.Copy(&snapshot, ringBuffer) 3797 err = &smithy.DeserializationError{ 3798 Err: fmt.Errorf("failed to decode response body, %w", err), 3799 Snapshot: snapshot.Bytes(), 3800 } 3801 return err 3802 } 3803 3804 err := awsRestjson1_deserializeDocumentTooManyRequestsException(&output, shape) 3805 3806 if err != nil { 3807 var snapshot bytes.Buffer 3808 io.Copy(&snapshot, ringBuffer) 3809 err = &smithy.DeserializationError{ 3810 Err: fmt.Errorf("failed to decode response body, %w", err), 3811 Snapshot: snapshot.Bytes(), 3812 } 3813 return err 3814 } 3815 3816 errorBody.Seek(0, io.SeekStart) 3817 3818 return output 3819} 3820 3821func awsRestjson1_deserializeDocument__listOf__integerMin1Max2147483647(v *[]int32, value interface{}) error { 3822 if v == nil { 3823 return fmt.Errorf("unexpected nil of type %T", v) 3824 } 3825 if value == nil { 3826 return nil 3827 } 3828 3829 shape, ok := value.([]interface{}) 3830 if !ok { 3831 return fmt.Errorf("unexpected JSON type %v", value) 3832 } 3833 3834 var cv []int32 3835 if *v == nil { 3836 cv = []int32{} 3837 } else { 3838 cv = *v 3839 } 3840 3841 for _, value := range shape { 3842 var col int32 3843 if value != nil { 3844 jtv, ok := value.(json.Number) 3845 if !ok { 3846 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 3847 } 3848 i64, err := jtv.Int64() 3849 if err != nil { 3850 return err 3851 } 3852 col = int32(i64) 3853 } 3854 cv = append(cv, col) 3855 3856 } 3857 *v = cv 3858 return nil 3859} 3860 3861func awsRestjson1_deserializeDocument__listOf__integerMin32Max8182(v *[]int32, value interface{}) error { 3862 if v == nil { 3863 return fmt.Errorf("unexpected nil of type %T", v) 3864 } 3865 if value == nil { 3866 return nil 3867 } 3868 3869 shape, ok := value.([]interface{}) 3870 if !ok { 3871 return fmt.Errorf("unexpected JSON type %v", value) 3872 } 3873 3874 var cv []int32 3875 if *v == nil { 3876 cv = []int32{} 3877 } else { 3878 cv = *v 3879 } 3880 3881 for _, value := range shape { 3882 var col int32 3883 if value != nil { 3884 jtv, ok := value.(json.Number) 3885 if !ok { 3886 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 3887 } 3888 i64, err := jtv.Int64() 3889 if err != nil { 3890 return err 3891 } 3892 col = int32(i64) 3893 } 3894 cv = append(cv, col) 3895 3896 } 3897 *v = cv 3898 return nil 3899} 3900 3901func awsRestjson1_deserializeDocument__listOf__integerMinNegative60Max6(v *[]int32, value interface{}) error { 3902 if v == nil { 3903 return fmt.Errorf("unexpected nil of type %T", v) 3904 } 3905 if value == nil { 3906 return nil 3907 } 3908 3909 shape, ok := value.([]interface{}) 3910 if !ok { 3911 return fmt.Errorf("unexpected JSON type %v", value) 3912 } 3913 3914 var cv []int32 3915 if *v == nil { 3916 cv = []int32{} 3917 } else { 3918 cv = *v 3919 } 3920 3921 for _, value := range shape { 3922 var col int32 3923 if value != nil { 3924 jtv, ok := value.(json.Number) 3925 if !ok { 3926 return fmt.Errorf("expected __integerMinNegative60Max6 to be json.Number, got %T instead", value) 3927 } 3928 i64, err := jtv.Int64() 3929 if err != nil { 3930 return err 3931 } 3932 col = int32(i64) 3933 } 3934 cv = append(cv, col) 3935 3936 } 3937 *v = cv 3938 return nil 3939} 3940 3941func awsRestjson1_deserializeDocument__listOf__string(v *[]string, value interface{}) error { 3942 if v == nil { 3943 return fmt.Errorf("unexpected nil of type %T", v) 3944 } 3945 if value == nil { 3946 return nil 3947 } 3948 3949 shape, ok := value.([]interface{}) 3950 if !ok { 3951 return fmt.Errorf("unexpected JSON type %v", value) 3952 } 3953 3954 var cv []string 3955 if *v == nil { 3956 cv = []string{} 3957 } else { 3958 cv = *v 3959 } 3960 3961 for _, value := range shape { 3962 var col string 3963 if value != nil { 3964 jtv, ok := value.(string) 3965 if !ok { 3966 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 3967 } 3968 col = jtv 3969 } 3970 cv = append(cv, col) 3971 3972 } 3973 *v = cv 3974 return nil 3975} 3976 3977func awsRestjson1_deserializeDocument__listOf__stringMin1(v *[]string, value interface{}) error { 3978 if v == nil { 3979 return fmt.Errorf("unexpected nil of type %T", v) 3980 } 3981 if value == nil { 3982 return nil 3983 } 3984 3985 shape, ok := value.([]interface{}) 3986 if !ok { 3987 return fmt.Errorf("unexpected JSON type %v", value) 3988 } 3989 3990 var cv []string 3991 if *v == nil { 3992 cv = []string{} 3993 } else { 3994 cv = *v 3995 } 3996 3997 for _, value := range shape { 3998 var col string 3999 if value != nil { 4000 jtv, ok := value.(string) 4001 if !ok { 4002 return fmt.Errorf("expected __stringMin1 to be of type string, got %T instead", value) 4003 } 4004 col = jtv 4005 } 4006 cv = append(cv, col) 4007 4008 } 4009 *v = cv 4010 return nil 4011} 4012 4013func awsRestjson1_deserializeDocument__listOf__stringMin36Max36Pattern09aFAF809aFAF409aFAF409aFAF409aFAF12(v *[]string, value interface{}) error { 4014 if v == nil { 4015 return fmt.Errorf("unexpected nil of type %T", v) 4016 } 4017 if value == nil { 4018 return nil 4019 } 4020 4021 shape, ok := value.([]interface{}) 4022 if !ok { 4023 return fmt.Errorf("unexpected JSON type %v", value) 4024 } 4025 4026 var cv []string 4027 if *v == nil { 4028 cv = []string{} 4029 } else { 4030 cv = *v 4031 } 4032 4033 for _, value := range shape { 4034 var col string 4035 if value != nil { 4036 jtv, ok := value.(string) 4037 if !ok { 4038 return fmt.Errorf("expected __stringMin36Max36Pattern09aFAF809aFAF409aFAF409aFAF409aFAF12 to be of type string, got %T instead", value) 4039 } 4040 col = jtv 4041 } 4042 cv = append(cv, col) 4043 4044 } 4045 *v = cv 4046 return nil 4047} 4048 4049func awsRestjson1_deserializeDocument__listOf__stringPattern09aFAF809aFAF409aFAF409aFAF409aFAF12(v *[]string, value interface{}) error { 4050 if v == nil { 4051 return fmt.Errorf("unexpected nil of type %T", v) 4052 } 4053 if value == nil { 4054 return nil 4055 } 4056 4057 shape, ok := value.([]interface{}) 4058 if !ok { 4059 return fmt.Errorf("unexpected JSON type %v", value) 4060 } 4061 4062 var cv []string 4063 if *v == nil { 4064 cv = []string{} 4065 } else { 4066 cv = *v 4067 } 4068 4069 for _, value := range shape { 4070 var col string 4071 if value != nil { 4072 jtv, ok := value.(string) 4073 if !ok { 4074 return fmt.Errorf("expected __stringPattern09aFAF809aFAF409aFAF409aFAF409aFAF12 to be of type string, got %T instead", value) 4075 } 4076 col = jtv 4077 } 4078 cv = append(cv, col) 4079 4080 } 4081 *v = cv 4082 return nil 4083} 4084 4085func awsRestjson1_deserializeDocument__listOf__stringPatternS3ASSETMAPXml(v *[]string, value interface{}) error { 4086 if v == nil { 4087 return fmt.Errorf("unexpected nil of type %T", v) 4088 } 4089 if value == nil { 4090 return nil 4091 } 4092 4093 shape, ok := value.([]interface{}) 4094 if !ok { 4095 return fmt.Errorf("unexpected JSON type %v", value) 4096 } 4097 4098 var cv []string 4099 if *v == nil { 4100 cv = []string{} 4101 } else { 4102 cv = *v 4103 } 4104 4105 for _, value := range shape { 4106 var col string 4107 if value != nil { 4108 jtv, ok := value.(string) 4109 if !ok { 4110 return fmt.Errorf("expected __stringPatternS3ASSETMAPXml to be of type string, got %T instead", value) 4111 } 4112 col = jtv 4113 } 4114 cv = append(cv, col) 4115 4116 } 4117 *v = cv 4118 return nil 4119} 4120 4121func awsRestjson1_deserializeDocument__listOfAudioDescription(v *[]types.AudioDescription, value interface{}) error { 4122 if v == nil { 4123 return fmt.Errorf("unexpected nil of type %T", v) 4124 } 4125 if value == nil { 4126 return nil 4127 } 4128 4129 shape, ok := value.([]interface{}) 4130 if !ok { 4131 return fmt.Errorf("unexpected JSON type %v", value) 4132 } 4133 4134 var cv []types.AudioDescription 4135 if *v == nil { 4136 cv = []types.AudioDescription{} 4137 } else { 4138 cv = *v 4139 } 4140 4141 for _, value := range shape { 4142 var col types.AudioDescription 4143 destAddr := &col 4144 if err := awsRestjson1_deserializeDocumentAudioDescription(&destAddr, value); err != nil { 4145 return err 4146 } 4147 col = *destAddr 4148 cv = append(cv, col) 4149 4150 } 4151 *v = cv 4152 return nil 4153} 4154 4155func awsRestjson1_deserializeDocument__listOfCaptionDescription(v *[]types.CaptionDescription, value interface{}) error { 4156 if v == nil { 4157 return fmt.Errorf("unexpected nil of type %T", v) 4158 } 4159 if value == nil { 4160 return nil 4161 } 4162 4163 shape, ok := value.([]interface{}) 4164 if !ok { 4165 return fmt.Errorf("unexpected JSON type %v", value) 4166 } 4167 4168 var cv []types.CaptionDescription 4169 if *v == nil { 4170 cv = []types.CaptionDescription{} 4171 } else { 4172 cv = *v 4173 } 4174 4175 for _, value := range shape { 4176 var col types.CaptionDescription 4177 destAddr := &col 4178 if err := awsRestjson1_deserializeDocumentCaptionDescription(&destAddr, value); err != nil { 4179 return err 4180 } 4181 col = *destAddr 4182 cv = append(cv, col) 4183 4184 } 4185 *v = cv 4186 return nil 4187} 4188 4189func awsRestjson1_deserializeDocument__listOfCaptionDescriptionPreset(v *[]types.CaptionDescriptionPreset, value interface{}) error { 4190 if v == nil { 4191 return fmt.Errorf("unexpected nil of type %T", v) 4192 } 4193 if value == nil { 4194 return nil 4195 } 4196 4197 shape, ok := value.([]interface{}) 4198 if !ok { 4199 return fmt.Errorf("unexpected JSON type %v", value) 4200 } 4201 4202 var cv []types.CaptionDescriptionPreset 4203 if *v == nil { 4204 cv = []types.CaptionDescriptionPreset{} 4205 } else { 4206 cv = *v 4207 } 4208 4209 for _, value := range shape { 4210 var col types.CaptionDescriptionPreset 4211 destAddr := &col 4212 if err := awsRestjson1_deserializeDocumentCaptionDescriptionPreset(&destAddr, value); err != nil { 4213 return err 4214 } 4215 col = *destAddr 4216 cv = append(cv, col) 4217 4218 } 4219 *v = cv 4220 return nil 4221} 4222 4223func awsRestjson1_deserializeDocument__listOfCmafAdditionalManifest(v *[]types.CmafAdditionalManifest, value interface{}) error { 4224 if v == nil { 4225 return fmt.Errorf("unexpected nil of type %T", v) 4226 } 4227 if value == nil { 4228 return nil 4229 } 4230 4231 shape, ok := value.([]interface{}) 4232 if !ok { 4233 return fmt.Errorf("unexpected JSON type %v", value) 4234 } 4235 4236 var cv []types.CmafAdditionalManifest 4237 if *v == nil { 4238 cv = []types.CmafAdditionalManifest{} 4239 } else { 4240 cv = *v 4241 } 4242 4243 for _, value := range shape { 4244 var col types.CmafAdditionalManifest 4245 destAddr := &col 4246 if err := awsRestjson1_deserializeDocumentCmafAdditionalManifest(&destAddr, value); err != nil { 4247 return err 4248 } 4249 col = *destAddr 4250 cv = append(cv, col) 4251 4252 } 4253 *v = cv 4254 return nil 4255} 4256 4257func awsRestjson1_deserializeDocument__listOfDashAdditionalManifest(v *[]types.DashAdditionalManifest, value interface{}) error { 4258 if v == nil { 4259 return fmt.Errorf("unexpected nil of type %T", v) 4260 } 4261 if value == nil { 4262 return nil 4263 } 4264 4265 shape, ok := value.([]interface{}) 4266 if !ok { 4267 return fmt.Errorf("unexpected JSON type %v", value) 4268 } 4269 4270 var cv []types.DashAdditionalManifest 4271 if *v == nil { 4272 cv = []types.DashAdditionalManifest{} 4273 } else { 4274 cv = *v 4275 } 4276 4277 for _, value := range shape { 4278 var col types.DashAdditionalManifest 4279 destAddr := &col 4280 if err := awsRestjson1_deserializeDocumentDashAdditionalManifest(&destAddr, value); err != nil { 4281 return err 4282 } 4283 col = *destAddr 4284 cv = append(cv, col) 4285 4286 } 4287 *v = cv 4288 return nil 4289} 4290 4291func awsRestjson1_deserializeDocument__listOfEndpoint(v *[]types.Endpoint, value interface{}) error { 4292 if v == nil { 4293 return fmt.Errorf("unexpected nil of type %T", v) 4294 } 4295 if value == nil { 4296 return nil 4297 } 4298 4299 shape, ok := value.([]interface{}) 4300 if !ok { 4301 return fmt.Errorf("unexpected JSON type %v", value) 4302 } 4303 4304 var cv []types.Endpoint 4305 if *v == nil { 4306 cv = []types.Endpoint{} 4307 } else { 4308 cv = *v 4309 } 4310 4311 for _, value := range shape { 4312 var col types.Endpoint 4313 destAddr := &col 4314 if err := awsRestjson1_deserializeDocumentEndpoint(&destAddr, value); err != nil { 4315 return err 4316 } 4317 col = *destAddr 4318 cv = append(cv, col) 4319 4320 } 4321 *v = cv 4322 return nil 4323} 4324 4325func awsRestjson1_deserializeDocument__listOfHlsAdditionalManifest(v *[]types.HlsAdditionalManifest, value interface{}) error { 4326 if v == nil { 4327 return fmt.Errorf("unexpected nil of type %T", v) 4328 } 4329 if value == nil { 4330 return nil 4331 } 4332 4333 shape, ok := value.([]interface{}) 4334 if !ok { 4335 return fmt.Errorf("unexpected JSON type %v", value) 4336 } 4337 4338 var cv []types.HlsAdditionalManifest 4339 if *v == nil { 4340 cv = []types.HlsAdditionalManifest{} 4341 } else { 4342 cv = *v 4343 } 4344 4345 for _, value := range shape { 4346 var col types.HlsAdditionalManifest 4347 destAddr := &col 4348 if err := awsRestjson1_deserializeDocumentHlsAdditionalManifest(&destAddr, value); err != nil { 4349 return err 4350 } 4351 col = *destAddr 4352 cv = append(cv, col) 4353 4354 } 4355 *v = cv 4356 return nil 4357} 4358 4359func awsRestjson1_deserializeDocument__listOfHlsAdMarkers(v *[]types.HlsAdMarkers, value interface{}) error { 4360 if v == nil { 4361 return fmt.Errorf("unexpected nil of type %T", v) 4362 } 4363 if value == nil { 4364 return nil 4365 } 4366 4367 shape, ok := value.([]interface{}) 4368 if !ok { 4369 return fmt.Errorf("unexpected JSON type %v", value) 4370 } 4371 4372 var cv []types.HlsAdMarkers 4373 if *v == nil { 4374 cv = []types.HlsAdMarkers{} 4375 } else { 4376 cv = *v 4377 } 4378 4379 for _, value := range shape { 4380 var col types.HlsAdMarkers 4381 if value != nil { 4382 jtv, ok := value.(string) 4383 if !ok { 4384 return fmt.Errorf("expected HlsAdMarkers to be of type string, got %T instead", value) 4385 } 4386 col = types.HlsAdMarkers(jtv) 4387 } 4388 cv = append(cv, col) 4389 4390 } 4391 *v = cv 4392 return nil 4393} 4394 4395func awsRestjson1_deserializeDocument__listOfHlsCaptionLanguageMapping(v *[]types.HlsCaptionLanguageMapping, value interface{}) error { 4396 if v == nil { 4397 return fmt.Errorf("unexpected nil of type %T", v) 4398 } 4399 if value == nil { 4400 return nil 4401 } 4402 4403 shape, ok := value.([]interface{}) 4404 if !ok { 4405 return fmt.Errorf("unexpected JSON type %v", value) 4406 } 4407 4408 var cv []types.HlsCaptionLanguageMapping 4409 if *v == nil { 4410 cv = []types.HlsCaptionLanguageMapping{} 4411 } else { 4412 cv = *v 4413 } 4414 4415 for _, value := range shape { 4416 var col types.HlsCaptionLanguageMapping 4417 destAddr := &col 4418 if err := awsRestjson1_deserializeDocumentHlsCaptionLanguageMapping(&destAddr, value); err != nil { 4419 return err 4420 } 4421 col = *destAddr 4422 cv = append(cv, col) 4423 4424 } 4425 *v = cv 4426 return nil 4427} 4428 4429func awsRestjson1_deserializeDocument__listOfHopDestination(v *[]types.HopDestination, value interface{}) error { 4430 if v == nil { 4431 return fmt.Errorf("unexpected nil of type %T", v) 4432 } 4433 if value == nil { 4434 return nil 4435 } 4436 4437 shape, ok := value.([]interface{}) 4438 if !ok { 4439 return fmt.Errorf("unexpected JSON type %v", value) 4440 } 4441 4442 var cv []types.HopDestination 4443 if *v == nil { 4444 cv = []types.HopDestination{} 4445 } else { 4446 cv = *v 4447 } 4448 4449 for _, value := range shape { 4450 var col types.HopDestination 4451 destAddr := &col 4452 if err := awsRestjson1_deserializeDocumentHopDestination(&destAddr, value); err != nil { 4453 return err 4454 } 4455 col = *destAddr 4456 cv = append(cv, col) 4457 4458 } 4459 *v = cv 4460 return nil 4461} 4462 4463func awsRestjson1_deserializeDocument__listOfId3Insertion(v *[]types.Id3Insertion, value interface{}) error { 4464 if v == nil { 4465 return fmt.Errorf("unexpected nil of type %T", v) 4466 } 4467 if value == nil { 4468 return nil 4469 } 4470 4471 shape, ok := value.([]interface{}) 4472 if !ok { 4473 return fmt.Errorf("unexpected JSON type %v", value) 4474 } 4475 4476 var cv []types.Id3Insertion 4477 if *v == nil { 4478 cv = []types.Id3Insertion{} 4479 } else { 4480 cv = *v 4481 } 4482 4483 for _, value := range shape { 4484 var col types.Id3Insertion 4485 destAddr := &col 4486 if err := awsRestjson1_deserializeDocumentId3Insertion(&destAddr, value); err != nil { 4487 return err 4488 } 4489 col = *destAddr 4490 cv = append(cv, col) 4491 4492 } 4493 *v = cv 4494 return nil 4495} 4496 4497func awsRestjson1_deserializeDocument__listOfInput(v *[]types.Input, value interface{}) error { 4498 if v == nil { 4499 return fmt.Errorf("unexpected nil of type %T", v) 4500 } 4501 if value == nil { 4502 return nil 4503 } 4504 4505 shape, ok := value.([]interface{}) 4506 if !ok { 4507 return fmt.Errorf("unexpected JSON type %v", value) 4508 } 4509 4510 var cv []types.Input 4511 if *v == nil { 4512 cv = []types.Input{} 4513 } else { 4514 cv = *v 4515 } 4516 4517 for _, value := range shape { 4518 var col types.Input 4519 destAddr := &col 4520 if err := awsRestjson1_deserializeDocumentInput(&destAddr, value); err != nil { 4521 return err 4522 } 4523 col = *destAddr 4524 cv = append(cv, col) 4525 4526 } 4527 *v = cv 4528 return nil 4529} 4530 4531func awsRestjson1_deserializeDocument__listOfInputClipping(v *[]types.InputClipping, value interface{}) error { 4532 if v == nil { 4533 return fmt.Errorf("unexpected nil of type %T", v) 4534 } 4535 if value == nil { 4536 return nil 4537 } 4538 4539 shape, ok := value.([]interface{}) 4540 if !ok { 4541 return fmt.Errorf("unexpected JSON type %v", value) 4542 } 4543 4544 var cv []types.InputClipping 4545 if *v == nil { 4546 cv = []types.InputClipping{} 4547 } else { 4548 cv = *v 4549 } 4550 4551 for _, value := range shape { 4552 var col types.InputClipping 4553 destAddr := &col 4554 if err := awsRestjson1_deserializeDocumentInputClipping(&destAddr, value); err != nil { 4555 return err 4556 } 4557 col = *destAddr 4558 cv = append(cv, col) 4559 4560 } 4561 *v = cv 4562 return nil 4563} 4564 4565func awsRestjson1_deserializeDocument__listOfInputTemplate(v *[]types.InputTemplate, value interface{}) error { 4566 if v == nil { 4567 return fmt.Errorf("unexpected nil of type %T", v) 4568 } 4569 if value == nil { 4570 return nil 4571 } 4572 4573 shape, ok := value.([]interface{}) 4574 if !ok { 4575 return fmt.Errorf("unexpected JSON type %v", value) 4576 } 4577 4578 var cv []types.InputTemplate 4579 if *v == nil { 4580 cv = []types.InputTemplate{} 4581 } else { 4582 cv = *v 4583 } 4584 4585 for _, value := range shape { 4586 var col types.InputTemplate 4587 destAddr := &col 4588 if err := awsRestjson1_deserializeDocumentInputTemplate(&destAddr, value); err != nil { 4589 return err 4590 } 4591 col = *destAddr 4592 cv = append(cv, col) 4593 4594 } 4595 *v = cv 4596 return nil 4597} 4598 4599func awsRestjson1_deserializeDocument__listOfInsertableImage(v *[]types.InsertableImage, value interface{}) error { 4600 if v == nil { 4601 return fmt.Errorf("unexpected nil of type %T", v) 4602 } 4603 if value == nil { 4604 return nil 4605 } 4606 4607 shape, ok := value.([]interface{}) 4608 if !ok { 4609 return fmt.Errorf("unexpected JSON type %v", value) 4610 } 4611 4612 var cv []types.InsertableImage 4613 if *v == nil { 4614 cv = []types.InsertableImage{} 4615 } else { 4616 cv = *v 4617 } 4618 4619 for _, value := range shape { 4620 var col types.InsertableImage 4621 destAddr := &col 4622 if err := awsRestjson1_deserializeDocumentInsertableImage(&destAddr, value); err != nil { 4623 return err 4624 } 4625 col = *destAddr 4626 cv = append(cv, col) 4627 4628 } 4629 *v = cv 4630 return nil 4631} 4632 4633func awsRestjson1_deserializeDocument__listOfJob(v *[]types.Job, value interface{}) error { 4634 if v == nil { 4635 return fmt.Errorf("unexpected nil of type %T", v) 4636 } 4637 if value == nil { 4638 return nil 4639 } 4640 4641 shape, ok := value.([]interface{}) 4642 if !ok { 4643 return fmt.Errorf("unexpected JSON type %v", value) 4644 } 4645 4646 var cv []types.Job 4647 if *v == nil { 4648 cv = []types.Job{} 4649 } else { 4650 cv = *v 4651 } 4652 4653 for _, value := range shape { 4654 var col types.Job 4655 destAddr := &col 4656 if err := awsRestjson1_deserializeDocumentJob(&destAddr, value); err != nil { 4657 return err 4658 } 4659 col = *destAddr 4660 cv = append(cv, col) 4661 4662 } 4663 *v = cv 4664 return nil 4665} 4666 4667func awsRestjson1_deserializeDocument__listOfJobTemplate(v *[]types.JobTemplate, value interface{}) error { 4668 if v == nil { 4669 return fmt.Errorf("unexpected nil of type %T", v) 4670 } 4671 if value == nil { 4672 return nil 4673 } 4674 4675 shape, ok := value.([]interface{}) 4676 if !ok { 4677 return fmt.Errorf("unexpected JSON type %v", value) 4678 } 4679 4680 var cv []types.JobTemplate 4681 if *v == nil { 4682 cv = []types.JobTemplate{} 4683 } else { 4684 cv = *v 4685 } 4686 4687 for _, value := range shape { 4688 var col types.JobTemplate 4689 destAddr := &col 4690 if err := awsRestjson1_deserializeDocumentJobTemplate(&destAddr, value); err != nil { 4691 return err 4692 } 4693 col = *destAddr 4694 cv = append(cv, col) 4695 4696 } 4697 *v = cv 4698 return nil 4699} 4700 4701func awsRestjson1_deserializeDocument__listOfMsSmoothAdditionalManifest(v *[]types.MsSmoothAdditionalManifest, value interface{}) error { 4702 if v == nil { 4703 return fmt.Errorf("unexpected nil of type %T", v) 4704 } 4705 if value == nil { 4706 return nil 4707 } 4708 4709 shape, ok := value.([]interface{}) 4710 if !ok { 4711 return fmt.Errorf("unexpected JSON type %v", value) 4712 } 4713 4714 var cv []types.MsSmoothAdditionalManifest 4715 if *v == nil { 4716 cv = []types.MsSmoothAdditionalManifest{} 4717 } else { 4718 cv = *v 4719 } 4720 4721 for _, value := range shape { 4722 var col types.MsSmoothAdditionalManifest 4723 destAddr := &col 4724 if err := awsRestjson1_deserializeDocumentMsSmoothAdditionalManifest(&destAddr, value); err != nil { 4725 return err 4726 } 4727 col = *destAddr 4728 cv = append(cv, col) 4729 4730 } 4731 *v = cv 4732 return nil 4733} 4734 4735func awsRestjson1_deserializeDocument__listOfOutput(v *[]types.Output, value interface{}) error { 4736 if v == nil { 4737 return fmt.Errorf("unexpected nil of type %T", v) 4738 } 4739 if value == nil { 4740 return nil 4741 } 4742 4743 shape, ok := value.([]interface{}) 4744 if !ok { 4745 return fmt.Errorf("unexpected JSON type %v", value) 4746 } 4747 4748 var cv []types.Output 4749 if *v == nil { 4750 cv = []types.Output{} 4751 } else { 4752 cv = *v 4753 } 4754 4755 for _, value := range shape { 4756 var col types.Output 4757 destAddr := &col 4758 if err := awsRestjson1_deserializeDocumentOutput(&destAddr, value); err != nil { 4759 return err 4760 } 4761 col = *destAddr 4762 cv = append(cv, col) 4763 4764 } 4765 *v = cv 4766 return nil 4767} 4768 4769func awsRestjson1_deserializeDocument__listOfOutputChannelMapping(v *[]types.OutputChannelMapping, value interface{}) error { 4770 if v == nil { 4771 return fmt.Errorf("unexpected nil of type %T", v) 4772 } 4773 if value == nil { 4774 return nil 4775 } 4776 4777 shape, ok := value.([]interface{}) 4778 if !ok { 4779 return fmt.Errorf("unexpected JSON type %v", value) 4780 } 4781 4782 var cv []types.OutputChannelMapping 4783 if *v == nil { 4784 cv = []types.OutputChannelMapping{} 4785 } else { 4786 cv = *v 4787 } 4788 4789 for _, value := range shape { 4790 var col types.OutputChannelMapping 4791 destAddr := &col 4792 if err := awsRestjson1_deserializeDocumentOutputChannelMapping(&destAddr, value); err != nil { 4793 return err 4794 } 4795 col = *destAddr 4796 cv = append(cv, col) 4797 4798 } 4799 *v = cv 4800 return nil 4801} 4802 4803func awsRestjson1_deserializeDocument__listOfOutputDetail(v *[]types.OutputDetail, value interface{}) error { 4804 if v == nil { 4805 return fmt.Errorf("unexpected nil of type %T", v) 4806 } 4807 if value == nil { 4808 return nil 4809 } 4810 4811 shape, ok := value.([]interface{}) 4812 if !ok { 4813 return fmt.Errorf("unexpected JSON type %v", value) 4814 } 4815 4816 var cv []types.OutputDetail 4817 if *v == nil { 4818 cv = []types.OutputDetail{} 4819 } else { 4820 cv = *v 4821 } 4822 4823 for _, value := range shape { 4824 var col types.OutputDetail 4825 destAddr := &col 4826 if err := awsRestjson1_deserializeDocumentOutputDetail(&destAddr, value); err != nil { 4827 return err 4828 } 4829 col = *destAddr 4830 cv = append(cv, col) 4831 4832 } 4833 *v = cv 4834 return nil 4835} 4836 4837func awsRestjson1_deserializeDocument__listOfOutputGroup(v *[]types.OutputGroup, value interface{}) error { 4838 if v == nil { 4839 return fmt.Errorf("unexpected nil of type %T", v) 4840 } 4841 if value == nil { 4842 return nil 4843 } 4844 4845 shape, ok := value.([]interface{}) 4846 if !ok { 4847 return fmt.Errorf("unexpected JSON type %v", value) 4848 } 4849 4850 var cv []types.OutputGroup 4851 if *v == nil { 4852 cv = []types.OutputGroup{} 4853 } else { 4854 cv = *v 4855 } 4856 4857 for _, value := range shape { 4858 var col types.OutputGroup 4859 destAddr := &col 4860 if err := awsRestjson1_deserializeDocumentOutputGroup(&destAddr, value); err != nil { 4861 return err 4862 } 4863 col = *destAddr 4864 cv = append(cv, col) 4865 4866 } 4867 *v = cv 4868 return nil 4869} 4870 4871func awsRestjson1_deserializeDocument__listOfOutputGroupDetail(v *[]types.OutputGroupDetail, value interface{}) error { 4872 if v == nil { 4873 return fmt.Errorf("unexpected nil of type %T", v) 4874 } 4875 if value == nil { 4876 return nil 4877 } 4878 4879 shape, ok := value.([]interface{}) 4880 if !ok { 4881 return fmt.Errorf("unexpected JSON type %v", value) 4882 } 4883 4884 var cv []types.OutputGroupDetail 4885 if *v == nil { 4886 cv = []types.OutputGroupDetail{} 4887 } else { 4888 cv = *v 4889 } 4890 4891 for _, value := range shape { 4892 var col types.OutputGroupDetail 4893 destAddr := &col 4894 if err := awsRestjson1_deserializeDocumentOutputGroupDetail(&destAddr, value); err != nil { 4895 return err 4896 } 4897 col = *destAddr 4898 cv = append(cv, col) 4899 4900 } 4901 *v = cv 4902 return nil 4903} 4904 4905func awsRestjson1_deserializeDocument__listOfPreset(v *[]types.Preset, value interface{}) error { 4906 if v == nil { 4907 return fmt.Errorf("unexpected nil of type %T", v) 4908 } 4909 if value == nil { 4910 return nil 4911 } 4912 4913 shape, ok := value.([]interface{}) 4914 if !ok { 4915 return fmt.Errorf("unexpected JSON type %v", value) 4916 } 4917 4918 var cv []types.Preset 4919 if *v == nil { 4920 cv = []types.Preset{} 4921 } else { 4922 cv = *v 4923 } 4924 4925 for _, value := range shape { 4926 var col types.Preset 4927 destAddr := &col 4928 if err := awsRestjson1_deserializeDocumentPreset(&destAddr, value); err != nil { 4929 return err 4930 } 4931 col = *destAddr 4932 cv = append(cv, col) 4933 4934 } 4935 *v = cv 4936 return nil 4937} 4938 4939func awsRestjson1_deserializeDocument__listOfQueue(v *[]types.Queue, value interface{}) error { 4940 if v == nil { 4941 return fmt.Errorf("unexpected nil of type %T", v) 4942 } 4943 if value == nil { 4944 return nil 4945 } 4946 4947 shape, ok := value.([]interface{}) 4948 if !ok { 4949 return fmt.Errorf("unexpected JSON type %v", value) 4950 } 4951 4952 var cv []types.Queue 4953 if *v == nil { 4954 cv = []types.Queue{} 4955 } else { 4956 cv = *v 4957 } 4958 4959 for _, value := range shape { 4960 var col types.Queue 4961 destAddr := &col 4962 if err := awsRestjson1_deserializeDocumentQueue(&destAddr, value); err != nil { 4963 return err 4964 } 4965 col = *destAddr 4966 cv = append(cv, col) 4967 4968 } 4969 *v = cv 4970 return nil 4971} 4972 4973func awsRestjson1_deserializeDocument__listOfQueueTransition(v *[]types.QueueTransition, value interface{}) error { 4974 if v == nil { 4975 return fmt.Errorf("unexpected nil of type %T", v) 4976 } 4977 if value == nil { 4978 return nil 4979 } 4980 4981 shape, ok := value.([]interface{}) 4982 if !ok { 4983 return fmt.Errorf("unexpected JSON type %v", value) 4984 } 4985 4986 var cv []types.QueueTransition 4987 if *v == nil { 4988 cv = []types.QueueTransition{} 4989 } else { 4990 cv = *v 4991 } 4992 4993 for _, value := range shape { 4994 var col types.QueueTransition 4995 destAddr := &col 4996 if err := awsRestjson1_deserializeDocumentQueueTransition(&destAddr, value); err != nil { 4997 return err 4998 } 4999 col = *destAddr 5000 cv = append(cv, col) 5001 5002 } 5003 *v = cv 5004 return nil 5005} 5006 5007func awsRestjson1_deserializeDocument__listOfTeletextPageType(v *[]types.TeletextPageType, value interface{}) error { 5008 if v == nil { 5009 return fmt.Errorf("unexpected nil of type %T", v) 5010 } 5011 if value == nil { 5012 return nil 5013 } 5014 5015 shape, ok := value.([]interface{}) 5016 if !ok { 5017 return fmt.Errorf("unexpected JSON type %v", value) 5018 } 5019 5020 var cv []types.TeletextPageType 5021 if *v == nil { 5022 cv = []types.TeletextPageType{} 5023 } else { 5024 cv = *v 5025 } 5026 5027 for _, value := range shape { 5028 var col types.TeletextPageType 5029 if value != nil { 5030 jtv, ok := value.(string) 5031 if !ok { 5032 return fmt.Errorf("expected TeletextPageType to be of type string, got %T instead", value) 5033 } 5034 col = types.TeletextPageType(jtv) 5035 } 5036 cv = append(cv, col) 5037 5038 } 5039 *v = cv 5040 return nil 5041} 5042 5043func awsRestjson1_deserializeDocument__mapOf__string(v *map[string]string, value interface{}) error { 5044 if v == nil { 5045 return fmt.Errorf("unexpected nil of type %T", v) 5046 } 5047 if value == nil { 5048 return nil 5049 } 5050 5051 shape, ok := value.(map[string]interface{}) 5052 if !ok { 5053 return fmt.Errorf("unexpected JSON type %v", value) 5054 } 5055 5056 var mv map[string]string 5057 if *v == nil { 5058 mv = map[string]string{} 5059 } else { 5060 mv = *v 5061 } 5062 5063 for key, value := range shape { 5064 var parsedVal string 5065 if value != nil { 5066 jtv, ok := value.(string) 5067 if !ok { 5068 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 5069 } 5070 parsedVal = jtv 5071 } 5072 mv[key] = parsedVal 5073 5074 } 5075 *v = mv 5076 return nil 5077} 5078 5079func awsRestjson1_deserializeDocument__mapOfAudioSelector(v *map[string]types.AudioSelector, value interface{}) error { 5080 if v == nil { 5081 return fmt.Errorf("unexpected nil of type %T", v) 5082 } 5083 if value == nil { 5084 return nil 5085 } 5086 5087 shape, ok := value.(map[string]interface{}) 5088 if !ok { 5089 return fmt.Errorf("unexpected JSON type %v", value) 5090 } 5091 5092 var mv map[string]types.AudioSelector 5093 if *v == nil { 5094 mv = map[string]types.AudioSelector{} 5095 } else { 5096 mv = *v 5097 } 5098 5099 for key, value := range shape { 5100 var parsedVal types.AudioSelector 5101 mapVar := parsedVal 5102 destAddr := &mapVar 5103 if err := awsRestjson1_deserializeDocumentAudioSelector(&destAddr, value); err != nil { 5104 return err 5105 } 5106 parsedVal = *destAddr 5107 mv[key] = parsedVal 5108 5109 } 5110 *v = mv 5111 return nil 5112} 5113 5114func awsRestjson1_deserializeDocument__mapOfAudioSelectorGroup(v *map[string]types.AudioSelectorGroup, value interface{}) error { 5115 if v == nil { 5116 return fmt.Errorf("unexpected nil of type %T", v) 5117 } 5118 if value == nil { 5119 return nil 5120 } 5121 5122 shape, ok := value.(map[string]interface{}) 5123 if !ok { 5124 return fmt.Errorf("unexpected JSON type %v", value) 5125 } 5126 5127 var mv map[string]types.AudioSelectorGroup 5128 if *v == nil { 5129 mv = map[string]types.AudioSelectorGroup{} 5130 } else { 5131 mv = *v 5132 } 5133 5134 for key, value := range shape { 5135 var parsedVal types.AudioSelectorGroup 5136 mapVar := parsedVal 5137 destAddr := &mapVar 5138 if err := awsRestjson1_deserializeDocumentAudioSelectorGroup(&destAddr, value); err != nil { 5139 return err 5140 } 5141 parsedVal = *destAddr 5142 mv[key] = parsedVal 5143 5144 } 5145 *v = mv 5146 return nil 5147} 5148 5149func awsRestjson1_deserializeDocument__mapOfCaptionSelector(v *map[string]types.CaptionSelector, value interface{}) error { 5150 if v == nil { 5151 return fmt.Errorf("unexpected nil of type %T", v) 5152 } 5153 if value == nil { 5154 return nil 5155 } 5156 5157 shape, ok := value.(map[string]interface{}) 5158 if !ok { 5159 return fmt.Errorf("unexpected JSON type %v", value) 5160 } 5161 5162 var mv map[string]types.CaptionSelector 5163 if *v == nil { 5164 mv = map[string]types.CaptionSelector{} 5165 } else { 5166 mv = *v 5167 } 5168 5169 for key, value := range shape { 5170 var parsedVal types.CaptionSelector 5171 mapVar := parsedVal 5172 destAddr := &mapVar 5173 if err := awsRestjson1_deserializeDocumentCaptionSelector(&destAddr, value); err != nil { 5174 return err 5175 } 5176 parsedVal = *destAddr 5177 mv[key] = parsedVal 5178 5179 } 5180 *v = mv 5181 return nil 5182} 5183 5184func awsRestjson1_deserializeDocumentAacSettings(v **types.AacSettings, value interface{}) error { 5185 if v == nil { 5186 return fmt.Errorf("unexpected nil of type %T", v) 5187 } 5188 if value == nil { 5189 return nil 5190 } 5191 5192 shape, ok := value.(map[string]interface{}) 5193 if !ok { 5194 return fmt.Errorf("unexpected JSON type %v", value) 5195 } 5196 5197 var sv *types.AacSettings 5198 if *v == nil { 5199 sv = &types.AacSettings{} 5200 } else { 5201 sv = *v 5202 } 5203 5204 for key, value := range shape { 5205 switch key { 5206 case "audioDescriptionBroadcasterMix": 5207 if value != nil { 5208 jtv, ok := value.(string) 5209 if !ok { 5210 return fmt.Errorf("expected AacAudioDescriptionBroadcasterMix to be of type string, got %T instead", value) 5211 } 5212 sv.AudioDescriptionBroadcasterMix = types.AacAudioDescriptionBroadcasterMix(jtv) 5213 } 5214 5215 case "bitrate": 5216 if value != nil { 5217 jtv, ok := value.(json.Number) 5218 if !ok { 5219 return fmt.Errorf("expected __integerMin6000Max1024000 to be json.Number, got %T instead", value) 5220 } 5221 i64, err := jtv.Int64() 5222 if err != nil { 5223 return err 5224 } 5225 sv.Bitrate = int32(i64) 5226 } 5227 5228 case "codecProfile": 5229 if value != nil { 5230 jtv, ok := value.(string) 5231 if !ok { 5232 return fmt.Errorf("expected AacCodecProfile to be of type string, got %T instead", value) 5233 } 5234 sv.CodecProfile = types.AacCodecProfile(jtv) 5235 } 5236 5237 case "codingMode": 5238 if value != nil { 5239 jtv, ok := value.(string) 5240 if !ok { 5241 return fmt.Errorf("expected AacCodingMode to be of type string, got %T instead", value) 5242 } 5243 sv.CodingMode = types.AacCodingMode(jtv) 5244 } 5245 5246 case "rateControlMode": 5247 if value != nil { 5248 jtv, ok := value.(string) 5249 if !ok { 5250 return fmt.Errorf("expected AacRateControlMode to be of type string, got %T instead", value) 5251 } 5252 sv.RateControlMode = types.AacRateControlMode(jtv) 5253 } 5254 5255 case "rawFormat": 5256 if value != nil { 5257 jtv, ok := value.(string) 5258 if !ok { 5259 return fmt.Errorf("expected AacRawFormat to be of type string, got %T instead", value) 5260 } 5261 sv.RawFormat = types.AacRawFormat(jtv) 5262 } 5263 5264 case "sampleRate": 5265 if value != nil { 5266 jtv, ok := value.(json.Number) 5267 if !ok { 5268 return fmt.Errorf("expected __integerMin8000Max96000 to be json.Number, got %T instead", value) 5269 } 5270 i64, err := jtv.Int64() 5271 if err != nil { 5272 return err 5273 } 5274 sv.SampleRate = int32(i64) 5275 } 5276 5277 case "specification": 5278 if value != nil { 5279 jtv, ok := value.(string) 5280 if !ok { 5281 return fmt.Errorf("expected AacSpecification to be of type string, got %T instead", value) 5282 } 5283 sv.Specification = types.AacSpecification(jtv) 5284 } 5285 5286 case "vbrQuality": 5287 if value != nil { 5288 jtv, ok := value.(string) 5289 if !ok { 5290 return fmt.Errorf("expected AacVbrQuality to be of type string, got %T instead", value) 5291 } 5292 sv.VbrQuality = types.AacVbrQuality(jtv) 5293 } 5294 5295 default: 5296 _, _ = key, value 5297 5298 } 5299 } 5300 *v = sv 5301 return nil 5302} 5303 5304func awsRestjson1_deserializeDocumentAc3Settings(v **types.Ac3Settings, value interface{}) error { 5305 if v == nil { 5306 return fmt.Errorf("unexpected nil of type %T", v) 5307 } 5308 if value == nil { 5309 return nil 5310 } 5311 5312 shape, ok := value.(map[string]interface{}) 5313 if !ok { 5314 return fmt.Errorf("unexpected JSON type %v", value) 5315 } 5316 5317 var sv *types.Ac3Settings 5318 if *v == nil { 5319 sv = &types.Ac3Settings{} 5320 } else { 5321 sv = *v 5322 } 5323 5324 for key, value := range shape { 5325 switch key { 5326 case "bitrate": 5327 if value != nil { 5328 jtv, ok := value.(json.Number) 5329 if !ok { 5330 return fmt.Errorf("expected __integerMin64000Max640000 to be json.Number, got %T instead", value) 5331 } 5332 i64, err := jtv.Int64() 5333 if err != nil { 5334 return err 5335 } 5336 sv.Bitrate = int32(i64) 5337 } 5338 5339 case "bitstreamMode": 5340 if value != nil { 5341 jtv, ok := value.(string) 5342 if !ok { 5343 return fmt.Errorf("expected Ac3BitstreamMode to be of type string, got %T instead", value) 5344 } 5345 sv.BitstreamMode = types.Ac3BitstreamMode(jtv) 5346 } 5347 5348 case "codingMode": 5349 if value != nil { 5350 jtv, ok := value.(string) 5351 if !ok { 5352 return fmt.Errorf("expected Ac3CodingMode to be of type string, got %T instead", value) 5353 } 5354 sv.CodingMode = types.Ac3CodingMode(jtv) 5355 } 5356 5357 case "dialnorm": 5358 if value != nil { 5359 jtv, ok := value.(json.Number) 5360 if !ok { 5361 return fmt.Errorf("expected __integerMin1Max31 to be json.Number, got %T instead", value) 5362 } 5363 i64, err := jtv.Int64() 5364 if err != nil { 5365 return err 5366 } 5367 sv.Dialnorm = int32(i64) 5368 } 5369 5370 case "dynamicRangeCompressionProfile": 5371 if value != nil { 5372 jtv, ok := value.(string) 5373 if !ok { 5374 return fmt.Errorf("expected Ac3DynamicRangeCompressionProfile to be of type string, got %T instead", value) 5375 } 5376 sv.DynamicRangeCompressionProfile = types.Ac3DynamicRangeCompressionProfile(jtv) 5377 } 5378 5379 case "lfeFilter": 5380 if value != nil { 5381 jtv, ok := value.(string) 5382 if !ok { 5383 return fmt.Errorf("expected Ac3LfeFilter to be of type string, got %T instead", value) 5384 } 5385 sv.LfeFilter = types.Ac3LfeFilter(jtv) 5386 } 5387 5388 case "metadataControl": 5389 if value != nil { 5390 jtv, ok := value.(string) 5391 if !ok { 5392 return fmt.Errorf("expected Ac3MetadataControl to be of type string, got %T instead", value) 5393 } 5394 sv.MetadataControl = types.Ac3MetadataControl(jtv) 5395 } 5396 5397 case "sampleRate": 5398 if value != nil { 5399 jtv, ok := value.(json.Number) 5400 if !ok { 5401 return fmt.Errorf("expected __integerMin48000Max48000 to be json.Number, got %T instead", value) 5402 } 5403 i64, err := jtv.Int64() 5404 if err != nil { 5405 return err 5406 } 5407 sv.SampleRate = int32(i64) 5408 } 5409 5410 default: 5411 _, _ = key, value 5412 5413 } 5414 } 5415 *v = sv 5416 return nil 5417} 5418 5419func awsRestjson1_deserializeDocumentAccelerationSettings(v **types.AccelerationSettings, value interface{}) error { 5420 if v == nil { 5421 return fmt.Errorf("unexpected nil of type %T", v) 5422 } 5423 if value == nil { 5424 return nil 5425 } 5426 5427 shape, ok := value.(map[string]interface{}) 5428 if !ok { 5429 return fmt.Errorf("unexpected JSON type %v", value) 5430 } 5431 5432 var sv *types.AccelerationSettings 5433 if *v == nil { 5434 sv = &types.AccelerationSettings{} 5435 } else { 5436 sv = *v 5437 } 5438 5439 for key, value := range shape { 5440 switch key { 5441 case "mode": 5442 if value != nil { 5443 jtv, ok := value.(string) 5444 if !ok { 5445 return fmt.Errorf("expected AccelerationMode to be of type string, got %T instead", value) 5446 } 5447 sv.Mode = types.AccelerationMode(jtv) 5448 } 5449 5450 default: 5451 _, _ = key, value 5452 5453 } 5454 } 5455 *v = sv 5456 return nil 5457} 5458 5459func awsRestjson1_deserializeDocumentAiffSettings(v **types.AiffSettings, value interface{}) error { 5460 if v == nil { 5461 return fmt.Errorf("unexpected nil of type %T", v) 5462 } 5463 if value == nil { 5464 return nil 5465 } 5466 5467 shape, ok := value.(map[string]interface{}) 5468 if !ok { 5469 return fmt.Errorf("unexpected JSON type %v", value) 5470 } 5471 5472 var sv *types.AiffSettings 5473 if *v == nil { 5474 sv = &types.AiffSettings{} 5475 } else { 5476 sv = *v 5477 } 5478 5479 for key, value := range shape { 5480 switch key { 5481 case "bitDepth": 5482 if value != nil { 5483 jtv, ok := value.(json.Number) 5484 if !ok { 5485 return fmt.Errorf("expected __integerMin16Max24 to be json.Number, got %T instead", value) 5486 } 5487 i64, err := jtv.Int64() 5488 if err != nil { 5489 return err 5490 } 5491 sv.BitDepth = int32(i64) 5492 } 5493 5494 case "channels": 5495 if value != nil { 5496 jtv, ok := value.(json.Number) 5497 if !ok { 5498 return fmt.Errorf("expected __integerMin1Max64 to be json.Number, got %T instead", value) 5499 } 5500 i64, err := jtv.Int64() 5501 if err != nil { 5502 return err 5503 } 5504 sv.Channels = int32(i64) 5505 } 5506 5507 case "sampleRate": 5508 if value != nil { 5509 jtv, ok := value.(json.Number) 5510 if !ok { 5511 return fmt.Errorf("expected __integerMin8000Max192000 to be json.Number, got %T instead", value) 5512 } 5513 i64, err := jtv.Int64() 5514 if err != nil { 5515 return err 5516 } 5517 sv.SampleRate = int32(i64) 5518 } 5519 5520 default: 5521 _, _ = key, value 5522 5523 } 5524 } 5525 *v = sv 5526 return nil 5527} 5528 5529func awsRestjson1_deserializeDocumentAncillarySourceSettings(v **types.AncillarySourceSettings, value interface{}) error { 5530 if v == nil { 5531 return fmt.Errorf("unexpected nil of type %T", v) 5532 } 5533 if value == nil { 5534 return nil 5535 } 5536 5537 shape, ok := value.(map[string]interface{}) 5538 if !ok { 5539 return fmt.Errorf("unexpected JSON type %v", value) 5540 } 5541 5542 var sv *types.AncillarySourceSettings 5543 if *v == nil { 5544 sv = &types.AncillarySourceSettings{} 5545 } else { 5546 sv = *v 5547 } 5548 5549 for key, value := range shape { 5550 switch key { 5551 case "convert608To708": 5552 if value != nil { 5553 jtv, ok := value.(string) 5554 if !ok { 5555 return fmt.Errorf("expected AncillaryConvert608To708 to be of type string, got %T instead", value) 5556 } 5557 sv.Convert608To708 = types.AncillaryConvert608To708(jtv) 5558 } 5559 5560 case "sourceAncillaryChannelNumber": 5561 if value != nil { 5562 jtv, ok := value.(json.Number) 5563 if !ok { 5564 return fmt.Errorf("expected __integerMin1Max4 to be json.Number, got %T instead", value) 5565 } 5566 i64, err := jtv.Int64() 5567 if err != nil { 5568 return err 5569 } 5570 sv.SourceAncillaryChannelNumber = int32(i64) 5571 } 5572 5573 case "terminateCaptions": 5574 if value != nil { 5575 jtv, ok := value.(string) 5576 if !ok { 5577 return fmt.Errorf("expected AncillaryTerminateCaptions to be of type string, got %T instead", value) 5578 } 5579 sv.TerminateCaptions = types.AncillaryTerminateCaptions(jtv) 5580 } 5581 5582 default: 5583 _, _ = key, value 5584 5585 } 5586 } 5587 *v = sv 5588 return nil 5589} 5590 5591func awsRestjson1_deserializeDocumentAudioChannelTaggingSettings(v **types.AudioChannelTaggingSettings, value interface{}) error { 5592 if v == nil { 5593 return fmt.Errorf("unexpected nil of type %T", v) 5594 } 5595 if value == nil { 5596 return nil 5597 } 5598 5599 shape, ok := value.(map[string]interface{}) 5600 if !ok { 5601 return fmt.Errorf("unexpected JSON type %v", value) 5602 } 5603 5604 var sv *types.AudioChannelTaggingSettings 5605 if *v == nil { 5606 sv = &types.AudioChannelTaggingSettings{} 5607 } else { 5608 sv = *v 5609 } 5610 5611 for key, value := range shape { 5612 switch key { 5613 case "channelTag": 5614 if value != nil { 5615 jtv, ok := value.(string) 5616 if !ok { 5617 return fmt.Errorf("expected AudioChannelTag to be of type string, got %T instead", value) 5618 } 5619 sv.ChannelTag = types.AudioChannelTag(jtv) 5620 } 5621 5622 default: 5623 _, _ = key, value 5624 5625 } 5626 } 5627 *v = sv 5628 return nil 5629} 5630 5631func awsRestjson1_deserializeDocumentAudioCodecSettings(v **types.AudioCodecSettings, value interface{}) error { 5632 if v == nil { 5633 return fmt.Errorf("unexpected nil of type %T", v) 5634 } 5635 if value == nil { 5636 return nil 5637 } 5638 5639 shape, ok := value.(map[string]interface{}) 5640 if !ok { 5641 return fmt.Errorf("unexpected JSON type %v", value) 5642 } 5643 5644 var sv *types.AudioCodecSettings 5645 if *v == nil { 5646 sv = &types.AudioCodecSettings{} 5647 } else { 5648 sv = *v 5649 } 5650 5651 for key, value := range shape { 5652 switch key { 5653 case "aacSettings": 5654 if err := awsRestjson1_deserializeDocumentAacSettings(&sv.AacSettings, value); err != nil { 5655 return err 5656 } 5657 5658 case "ac3Settings": 5659 if err := awsRestjson1_deserializeDocumentAc3Settings(&sv.Ac3Settings, value); err != nil { 5660 return err 5661 } 5662 5663 case "aiffSettings": 5664 if err := awsRestjson1_deserializeDocumentAiffSettings(&sv.AiffSettings, value); err != nil { 5665 return err 5666 } 5667 5668 case "codec": 5669 if value != nil { 5670 jtv, ok := value.(string) 5671 if !ok { 5672 return fmt.Errorf("expected AudioCodec to be of type string, got %T instead", value) 5673 } 5674 sv.Codec = types.AudioCodec(jtv) 5675 } 5676 5677 case "eac3AtmosSettings": 5678 if err := awsRestjson1_deserializeDocumentEac3AtmosSettings(&sv.Eac3AtmosSettings, value); err != nil { 5679 return err 5680 } 5681 5682 case "eac3Settings": 5683 if err := awsRestjson1_deserializeDocumentEac3Settings(&sv.Eac3Settings, value); err != nil { 5684 return err 5685 } 5686 5687 case "mp2Settings": 5688 if err := awsRestjson1_deserializeDocumentMp2Settings(&sv.Mp2Settings, value); err != nil { 5689 return err 5690 } 5691 5692 case "mp3Settings": 5693 if err := awsRestjson1_deserializeDocumentMp3Settings(&sv.Mp3Settings, value); err != nil { 5694 return err 5695 } 5696 5697 case "opusSettings": 5698 if err := awsRestjson1_deserializeDocumentOpusSettings(&sv.OpusSettings, value); err != nil { 5699 return err 5700 } 5701 5702 case "vorbisSettings": 5703 if err := awsRestjson1_deserializeDocumentVorbisSettings(&sv.VorbisSettings, value); err != nil { 5704 return err 5705 } 5706 5707 case "wavSettings": 5708 if err := awsRestjson1_deserializeDocumentWavSettings(&sv.WavSettings, value); err != nil { 5709 return err 5710 } 5711 5712 default: 5713 _, _ = key, value 5714 5715 } 5716 } 5717 *v = sv 5718 return nil 5719} 5720 5721func awsRestjson1_deserializeDocumentAudioDescription(v **types.AudioDescription, value interface{}) error { 5722 if v == nil { 5723 return fmt.Errorf("unexpected nil of type %T", v) 5724 } 5725 if value == nil { 5726 return nil 5727 } 5728 5729 shape, ok := value.(map[string]interface{}) 5730 if !ok { 5731 return fmt.Errorf("unexpected JSON type %v", value) 5732 } 5733 5734 var sv *types.AudioDescription 5735 if *v == nil { 5736 sv = &types.AudioDescription{} 5737 } else { 5738 sv = *v 5739 } 5740 5741 for key, value := range shape { 5742 switch key { 5743 case "audioChannelTaggingSettings": 5744 if err := awsRestjson1_deserializeDocumentAudioChannelTaggingSettings(&sv.AudioChannelTaggingSettings, value); err != nil { 5745 return err 5746 } 5747 5748 case "audioNormalizationSettings": 5749 if err := awsRestjson1_deserializeDocumentAudioNormalizationSettings(&sv.AudioNormalizationSettings, value); err != nil { 5750 return err 5751 } 5752 5753 case "audioSourceName": 5754 if value != nil { 5755 jtv, ok := value.(string) 5756 if !ok { 5757 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 5758 } 5759 sv.AudioSourceName = ptr.String(jtv) 5760 } 5761 5762 case "audioType": 5763 if value != nil { 5764 jtv, ok := value.(json.Number) 5765 if !ok { 5766 return fmt.Errorf("expected __integerMin0Max255 to be json.Number, got %T instead", value) 5767 } 5768 i64, err := jtv.Int64() 5769 if err != nil { 5770 return err 5771 } 5772 sv.AudioType = int32(i64) 5773 } 5774 5775 case "audioTypeControl": 5776 if value != nil { 5777 jtv, ok := value.(string) 5778 if !ok { 5779 return fmt.Errorf("expected AudioTypeControl to be of type string, got %T instead", value) 5780 } 5781 sv.AudioTypeControl = types.AudioTypeControl(jtv) 5782 } 5783 5784 case "codecSettings": 5785 if err := awsRestjson1_deserializeDocumentAudioCodecSettings(&sv.CodecSettings, value); err != nil { 5786 return err 5787 } 5788 5789 case "customLanguageCode": 5790 if value != nil { 5791 jtv, ok := value.(string) 5792 if !ok { 5793 return fmt.Errorf("expected __stringPatternAZaZ23AZaZ to be of type string, got %T instead", value) 5794 } 5795 sv.CustomLanguageCode = ptr.String(jtv) 5796 } 5797 5798 case "languageCode": 5799 if value != nil { 5800 jtv, ok := value.(string) 5801 if !ok { 5802 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 5803 } 5804 sv.LanguageCode = types.LanguageCode(jtv) 5805 } 5806 5807 case "languageCodeControl": 5808 if value != nil { 5809 jtv, ok := value.(string) 5810 if !ok { 5811 return fmt.Errorf("expected AudioLanguageCodeControl to be of type string, got %T instead", value) 5812 } 5813 sv.LanguageCodeControl = types.AudioLanguageCodeControl(jtv) 5814 } 5815 5816 case "remixSettings": 5817 if err := awsRestjson1_deserializeDocumentRemixSettings(&sv.RemixSettings, value); err != nil { 5818 return err 5819 } 5820 5821 case "streamName": 5822 if value != nil { 5823 jtv, ok := value.(string) 5824 if !ok { 5825 return fmt.Errorf("expected __stringPatternWS to be of type string, got %T instead", value) 5826 } 5827 sv.StreamName = ptr.String(jtv) 5828 } 5829 5830 default: 5831 _, _ = key, value 5832 5833 } 5834 } 5835 *v = sv 5836 return nil 5837} 5838 5839func awsRestjson1_deserializeDocumentAudioNormalizationSettings(v **types.AudioNormalizationSettings, value interface{}) error { 5840 if v == nil { 5841 return fmt.Errorf("unexpected nil of type %T", v) 5842 } 5843 if value == nil { 5844 return nil 5845 } 5846 5847 shape, ok := value.(map[string]interface{}) 5848 if !ok { 5849 return fmt.Errorf("unexpected JSON type %v", value) 5850 } 5851 5852 var sv *types.AudioNormalizationSettings 5853 if *v == nil { 5854 sv = &types.AudioNormalizationSettings{} 5855 } else { 5856 sv = *v 5857 } 5858 5859 for key, value := range shape { 5860 switch key { 5861 case "algorithm": 5862 if value != nil { 5863 jtv, ok := value.(string) 5864 if !ok { 5865 return fmt.Errorf("expected AudioNormalizationAlgorithm to be of type string, got %T instead", value) 5866 } 5867 sv.Algorithm = types.AudioNormalizationAlgorithm(jtv) 5868 } 5869 5870 case "algorithmControl": 5871 if value != nil { 5872 jtv, ok := value.(string) 5873 if !ok { 5874 return fmt.Errorf("expected AudioNormalizationAlgorithmControl to be of type string, got %T instead", value) 5875 } 5876 sv.AlgorithmControl = types.AudioNormalizationAlgorithmControl(jtv) 5877 } 5878 5879 case "correctionGateLevel": 5880 if value != nil { 5881 jtv, ok := value.(json.Number) 5882 if !ok { 5883 return fmt.Errorf("expected __integerMinNegative70Max0 to be json.Number, got %T instead", value) 5884 } 5885 i64, err := jtv.Int64() 5886 if err != nil { 5887 return err 5888 } 5889 sv.CorrectionGateLevel = int32(i64) 5890 } 5891 5892 case "loudnessLogging": 5893 if value != nil { 5894 jtv, ok := value.(string) 5895 if !ok { 5896 return fmt.Errorf("expected AudioNormalizationLoudnessLogging to be of type string, got %T instead", value) 5897 } 5898 sv.LoudnessLogging = types.AudioNormalizationLoudnessLogging(jtv) 5899 } 5900 5901 case "peakCalculation": 5902 if value != nil { 5903 jtv, ok := value.(string) 5904 if !ok { 5905 return fmt.Errorf("expected AudioNormalizationPeakCalculation to be of type string, got %T instead", value) 5906 } 5907 sv.PeakCalculation = types.AudioNormalizationPeakCalculation(jtv) 5908 } 5909 5910 case "targetLkfs": 5911 if value != nil { 5912 jtv, ok := value.(json.Number) 5913 if !ok { 5914 return fmt.Errorf("expected __doubleMinNegative59Max0 to be json.Number, got %T instead", value) 5915 } 5916 f64, err := jtv.Float64() 5917 if err != nil { 5918 return err 5919 } 5920 sv.TargetLkfs = f64 5921 } 5922 5923 default: 5924 _, _ = key, value 5925 5926 } 5927 } 5928 *v = sv 5929 return nil 5930} 5931 5932func awsRestjson1_deserializeDocumentAudioSelector(v **types.AudioSelector, value interface{}) error { 5933 if v == nil { 5934 return fmt.Errorf("unexpected nil of type %T", v) 5935 } 5936 if value == nil { 5937 return nil 5938 } 5939 5940 shape, ok := value.(map[string]interface{}) 5941 if !ok { 5942 return fmt.Errorf("unexpected JSON type %v", value) 5943 } 5944 5945 var sv *types.AudioSelector 5946 if *v == nil { 5947 sv = &types.AudioSelector{} 5948 } else { 5949 sv = *v 5950 } 5951 5952 for key, value := range shape { 5953 switch key { 5954 case "customLanguageCode": 5955 if value != nil { 5956 jtv, ok := value.(string) 5957 if !ok { 5958 return fmt.Errorf("expected __stringMin3Max3PatternAZaZ3 to be of type string, got %T instead", value) 5959 } 5960 sv.CustomLanguageCode = ptr.String(jtv) 5961 } 5962 5963 case "defaultSelection": 5964 if value != nil { 5965 jtv, ok := value.(string) 5966 if !ok { 5967 return fmt.Errorf("expected AudioDefaultSelection to be of type string, got %T instead", value) 5968 } 5969 sv.DefaultSelection = types.AudioDefaultSelection(jtv) 5970 } 5971 5972 case "externalAudioFileInput": 5973 if value != nil { 5974 jtv, ok := value.(string) 5975 if !ok { 5976 return fmt.Errorf("expected __stringPatternS3MM2PPWWEEBBMMMM2VVMMPPEEGGMMPP3AAVVIIMMPP4FFLLVVMMPPTTMMPPGGMM4VVTTRRPPFF4VVMM2TTSSTTSS264HH264MMKKVVMMKKAAMMOOVVMMTTSSMM2TTWWMMVVAASSFFVVOOBB3GGPP3GGPPPPMMXXFFDDIIVVXXXXVVIIDDRRAAWWDDVVGGXXFFMM1VV3GG2VVMMFFMM3UU8LLCCHHGGXXFFMMPPEEGG2MMXXFFMMPPEEGG2MMXXFFHHDDWWAAVVYY4MMAAAACCAAIIFFFFMMPP2AACC3EECC3DDTTSSEEHttpsMM2VVMMPPEEGGMMPP3AAVVIIMMPP4FFLLVVMMPPTTMMPPGGMM4VVTTRRPPFF4VVMM2TTSSTTSS264HH264MMKKVVMMKKAAMMOOVVMMTTSSMM2TTWWMMVVAASSFFVVOOBB3GGPP3GGPPPPMMXXFFDDIIVVXXXXVVIIDDRRAAWWDDVVGGXXFFMM1VV3GG2VVMMFFMM3UU8LLCCHHGGXXFFMMPPEEGG2MMXXFFMMPPEEGG2MMXXFFHHDDWWAAVVYY4MMAAAACCAAIIFFFFMMPP2AACC3EECC3DDTTSSEE to be of type string, got %T instead", value) 5977 } 5978 sv.ExternalAudioFileInput = ptr.String(jtv) 5979 } 5980 5981 case "languageCode": 5982 if value != nil { 5983 jtv, ok := value.(string) 5984 if !ok { 5985 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 5986 } 5987 sv.LanguageCode = types.LanguageCode(jtv) 5988 } 5989 5990 case "offset": 5991 if value != nil { 5992 jtv, ok := value.(json.Number) 5993 if !ok { 5994 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 5995 } 5996 i64, err := jtv.Int64() 5997 if err != nil { 5998 return err 5999 } 6000 sv.Offset = int32(i64) 6001 } 6002 6003 case "pids": 6004 if err := awsRestjson1_deserializeDocument__listOf__integerMin1Max2147483647(&sv.Pids, value); err != nil { 6005 return err 6006 } 6007 6008 case "programSelection": 6009 if value != nil { 6010 jtv, ok := value.(json.Number) 6011 if !ok { 6012 return fmt.Errorf("expected __integerMin0Max8 to be json.Number, got %T instead", value) 6013 } 6014 i64, err := jtv.Int64() 6015 if err != nil { 6016 return err 6017 } 6018 sv.ProgramSelection = int32(i64) 6019 } 6020 6021 case "remixSettings": 6022 if err := awsRestjson1_deserializeDocumentRemixSettings(&sv.RemixSettings, value); err != nil { 6023 return err 6024 } 6025 6026 case "selectorType": 6027 if value != nil { 6028 jtv, ok := value.(string) 6029 if !ok { 6030 return fmt.Errorf("expected AudioSelectorType to be of type string, got %T instead", value) 6031 } 6032 sv.SelectorType = types.AudioSelectorType(jtv) 6033 } 6034 6035 case "tracks": 6036 if err := awsRestjson1_deserializeDocument__listOf__integerMin1Max2147483647(&sv.Tracks, value); err != nil { 6037 return err 6038 } 6039 6040 default: 6041 _, _ = key, value 6042 6043 } 6044 } 6045 *v = sv 6046 return nil 6047} 6048 6049func awsRestjson1_deserializeDocumentAudioSelectorGroup(v **types.AudioSelectorGroup, value interface{}) error { 6050 if v == nil { 6051 return fmt.Errorf("unexpected nil of type %T", v) 6052 } 6053 if value == nil { 6054 return nil 6055 } 6056 6057 shape, ok := value.(map[string]interface{}) 6058 if !ok { 6059 return fmt.Errorf("unexpected JSON type %v", value) 6060 } 6061 6062 var sv *types.AudioSelectorGroup 6063 if *v == nil { 6064 sv = &types.AudioSelectorGroup{} 6065 } else { 6066 sv = *v 6067 } 6068 6069 for key, value := range shape { 6070 switch key { 6071 case "audioSelectorNames": 6072 if err := awsRestjson1_deserializeDocument__listOf__stringMin1(&sv.AudioSelectorNames, value); err != nil { 6073 return err 6074 } 6075 6076 default: 6077 _, _ = key, value 6078 6079 } 6080 } 6081 *v = sv 6082 return nil 6083} 6084 6085func awsRestjson1_deserializeDocumentAutomatedAbrSettings(v **types.AutomatedAbrSettings, value interface{}) error { 6086 if v == nil { 6087 return fmt.Errorf("unexpected nil of type %T", v) 6088 } 6089 if value == nil { 6090 return nil 6091 } 6092 6093 shape, ok := value.(map[string]interface{}) 6094 if !ok { 6095 return fmt.Errorf("unexpected JSON type %v", value) 6096 } 6097 6098 var sv *types.AutomatedAbrSettings 6099 if *v == nil { 6100 sv = &types.AutomatedAbrSettings{} 6101 } else { 6102 sv = *v 6103 } 6104 6105 for key, value := range shape { 6106 switch key { 6107 case "maxAbrBitrate": 6108 if value != nil { 6109 jtv, ok := value.(json.Number) 6110 if !ok { 6111 return fmt.Errorf("expected __integerMin100000Max100000000 to be json.Number, got %T instead", value) 6112 } 6113 i64, err := jtv.Int64() 6114 if err != nil { 6115 return err 6116 } 6117 sv.MaxAbrBitrate = int32(i64) 6118 } 6119 6120 case "maxRenditions": 6121 if value != nil { 6122 jtv, ok := value.(json.Number) 6123 if !ok { 6124 return fmt.Errorf("expected __integerMin3Max15 to be json.Number, got %T instead", value) 6125 } 6126 i64, err := jtv.Int64() 6127 if err != nil { 6128 return err 6129 } 6130 sv.MaxRenditions = int32(i64) 6131 } 6132 6133 case "minAbrBitrate": 6134 if value != nil { 6135 jtv, ok := value.(json.Number) 6136 if !ok { 6137 return fmt.Errorf("expected __integerMin100000Max100000000 to be json.Number, got %T instead", value) 6138 } 6139 i64, err := jtv.Int64() 6140 if err != nil { 6141 return err 6142 } 6143 sv.MinAbrBitrate = int32(i64) 6144 } 6145 6146 default: 6147 _, _ = key, value 6148 6149 } 6150 } 6151 *v = sv 6152 return nil 6153} 6154 6155func awsRestjson1_deserializeDocumentAutomatedEncodingSettings(v **types.AutomatedEncodingSettings, 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.AutomatedEncodingSettings 6169 if *v == nil { 6170 sv = &types.AutomatedEncodingSettings{} 6171 } else { 6172 sv = *v 6173 } 6174 6175 for key, value := range shape { 6176 switch key { 6177 case "abrSettings": 6178 if err := awsRestjson1_deserializeDocumentAutomatedAbrSettings(&sv.AbrSettings, 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_deserializeDocumentAv1QvbrSettings(v **types.Av1QvbrSettings, 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.Av1QvbrSettings 6205 if *v == nil { 6206 sv = &types.Av1QvbrSettings{} 6207 } else { 6208 sv = *v 6209 } 6210 6211 for key, value := range shape { 6212 switch key { 6213 case "qvbrQualityLevel": 6214 if value != nil { 6215 jtv, ok := value.(json.Number) 6216 if !ok { 6217 return fmt.Errorf("expected __integerMin1Max10 to be json.Number, got %T instead", value) 6218 } 6219 i64, err := jtv.Int64() 6220 if err != nil { 6221 return err 6222 } 6223 sv.QvbrQualityLevel = int32(i64) 6224 } 6225 6226 case "qvbrQualityLevelFineTune": 6227 if value != nil { 6228 jtv, ok := value.(json.Number) 6229 if !ok { 6230 return fmt.Errorf("expected __doubleMin0Max1 to be json.Number, got %T instead", value) 6231 } 6232 f64, err := jtv.Float64() 6233 if err != nil { 6234 return err 6235 } 6236 sv.QvbrQualityLevelFineTune = f64 6237 } 6238 6239 default: 6240 _, _ = key, value 6241 6242 } 6243 } 6244 *v = sv 6245 return nil 6246} 6247 6248func awsRestjson1_deserializeDocumentAv1Settings(v **types.Av1Settings, value interface{}) error { 6249 if v == nil { 6250 return fmt.Errorf("unexpected nil of type %T", v) 6251 } 6252 if value == nil { 6253 return nil 6254 } 6255 6256 shape, ok := value.(map[string]interface{}) 6257 if !ok { 6258 return fmt.Errorf("unexpected JSON type %v", value) 6259 } 6260 6261 var sv *types.Av1Settings 6262 if *v == nil { 6263 sv = &types.Av1Settings{} 6264 } else { 6265 sv = *v 6266 } 6267 6268 for key, value := range shape { 6269 switch key { 6270 case "adaptiveQuantization": 6271 if value != nil { 6272 jtv, ok := value.(string) 6273 if !ok { 6274 return fmt.Errorf("expected Av1AdaptiveQuantization to be of type string, got %T instead", value) 6275 } 6276 sv.AdaptiveQuantization = types.Av1AdaptiveQuantization(jtv) 6277 } 6278 6279 case "framerateControl": 6280 if value != nil { 6281 jtv, ok := value.(string) 6282 if !ok { 6283 return fmt.Errorf("expected Av1FramerateControl to be of type string, got %T instead", value) 6284 } 6285 sv.FramerateControl = types.Av1FramerateControl(jtv) 6286 } 6287 6288 case "framerateConversionAlgorithm": 6289 if value != nil { 6290 jtv, ok := value.(string) 6291 if !ok { 6292 return fmt.Errorf("expected Av1FramerateConversionAlgorithm to be of type string, got %T instead", value) 6293 } 6294 sv.FramerateConversionAlgorithm = types.Av1FramerateConversionAlgorithm(jtv) 6295 } 6296 6297 case "framerateDenominator": 6298 if value != nil { 6299 jtv, ok := value.(json.Number) 6300 if !ok { 6301 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 6302 } 6303 i64, err := jtv.Int64() 6304 if err != nil { 6305 return err 6306 } 6307 sv.FramerateDenominator = int32(i64) 6308 } 6309 6310 case "framerateNumerator": 6311 if value != nil { 6312 jtv, ok := value.(json.Number) 6313 if !ok { 6314 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 6315 } 6316 i64, err := jtv.Int64() 6317 if err != nil { 6318 return err 6319 } 6320 sv.FramerateNumerator = int32(i64) 6321 } 6322 6323 case "gopSize": 6324 if value != nil { 6325 jtv, ok := value.(json.Number) 6326 if !ok { 6327 return fmt.Errorf("expected __doubleMin0 to be json.Number, got %T instead", value) 6328 } 6329 f64, err := jtv.Float64() 6330 if err != nil { 6331 return err 6332 } 6333 sv.GopSize = f64 6334 } 6335 6336 case "maxBitrate": 6337 if value != nil { 6338 jtv, ok := value.(json.Number) 6339 if !ok { 6340 return fmt.Errorf("expected __integerMin1000Max1152000000 to be json.Number, got %T instead", value) 6341 } 6342 i64, err := jtv.Int64() 6343 if err != nil { 6344 return err 6345 } 6346 sv.MaxBitrate = int32(i64) 6347 } 6348 6349 case "numberBFramesBetweenReferenceFrames": 6350 if value != nil { 6351 jtv, ok := value.(json.Number) 6352 if !ok { 6353 return fmt.Errorf("expected __integerMin7Max15 to be json.Number, got %T instead", value) 6354 } 6355 i64, err := jtv.Int64() 6356 if err != nil { 6357 return err 6358 } 6359 sv.NumberBFramesBetweenReferenceFrames = int32(i64) 6360 } 6361 6362 case "qvbrSettings": 6363 if err := awsRestjson1_deserializeDocumentAv1QvbrSettings(&sv.QvbrSettings, value); err != nil { 6364 return err 6365 } 6366 6367 case "rateControlMode": 6368 if value != nil { 6369 jtv, ok := value.(string) 6370 if !ok { 6371 return fmt.Errorf("expected Av1RateControlMode to be of type string, got %T instead", value) 6372 } 6373 sv.RateControlMode = types.Av1RateControlMode(jtv) 6374 } 6375 6376 case "slices": 6377 if value != nil { 6378 jtv, ok := value.(json.Number) 6379 if !ok { 6380 return fmt.Errorf("expected __integerMin1Max32 to be json.Number, got %T instead", value) 6381 } 6382 i64, err := jtv.Int64() 6383 if err != nil { 6384 return err 6385 } 6386 sv.Slices = int32(i64) 6387 } 6388 6389 case "spatialAdaptiveQuantization": 6390 if value != nil { 6391 jtv, ok := value.(string) 6392 if !ok { 6393 return fmt.Errorf("expected Av1SpatialAdaptiveQuantization to be of type string, got %T instead", value) 6394 } 6395 sv.SpatialAdaptiveQuantization = types.Av1SpatialAdaptiveQuantization(jtv) 6396 } 6397 6398 default: 6399 _, _ = key, value 6400 6401 } 6402 } 6403 *v = sv 6404 return nil 6405} 6406 6407func awsRestjson1_deserializeDocumentAvailBlanking(v **types.AvailBlanking, value interface{}) error { 6408 if v == nil { 6409 return fmt.Errorf("unexpected nil of type %T", v) 6410 } 6411 if value == nil { 6412 return nil 6413 } 6414 6415 shape, ok := value.(map[string]interface{}) 6416 if !ok { 6417 return fmt.Errorf("unexpected JSON type %v", value) 6418 } 6419 6420 var sv *types.AvailBlanking 6421 if *v == nil { 6422 sv = &types.AvailBlanking{} 6423 } else { 6424 sv = *v 6425 } 6426 6427 for key, value := range shape { 6428 switch key { 6429 case "availBlankingImage": 6430 if value != nil { 6431 jtv, ok := value.(string) 6432 if !ok { 6433 return fmt.Errorf("expected __stringMin14PatternS3BmpBMPPngPNGHttpsBmpBMPPngPNG to be of type string, got %T instead", value) 6434 } 6435 sv.AvailBlankingImage = ptr.String(jtv) 6436 } 6437 6438 default: 6439 _, _ = key, value 6440 6441 } 6442 } 6443 *v = sv 6444 return nil 6445} 6446 6447func awsRestjson1_deserializeDocumentAvcIntraSettings(v **types.AvcIntraSettings, value interface{}) error { 6448 if v == nil { 6449 return fmt.Errorf("unexpected nil of type %T", v) 6450 } 6451 if value == nil { 6452 return nil 6453 } 6454 6455 shape, ok := value.(map[string]interface{}) 6456 if !ok { 6457 return fmt.Errorf("unexpected JSON type %v", value) 6458 } 6459 6460 var sv *types.AvcIntraSettings 6461 if *v == nil { 6462 sv = &types.AvcIntraSettings{} 6463 } else { 6464 sv = *v 6465 } 6466 6467 for key, value := range shape { 6468 switch key { 6469 case "avcIntraClass": 6470 if value != nil { 6471 jtv, ok := value.(string) 6472 if !ok { 6473 return fmt.Errorf("expected AvcIntraClass to be of type string, got %T instead", value) 6474 } 6475 sv.AvcIntraClass = types.AvcIntraClass(jtv) 6476 } 6477 6478 case "framerateControl": 6479 if value != nil { 6480 jtv, ok := value.(string) 6481 if !ok { 6482 return fmt.Errorf("expected AvcIntraFramerateControl to be of type string, got %T instead", value) 6483 } 6484 sv.FramerateControl = types.AvcIntraFramerateControl(jtv) 6485 } 6486 6487 case "framerateConversionAlgorithm": 6488 if value != nil { 6489 jtv, ok := value.(string) 6490 if !ok { 6491 return fmt.Errorf("expected AvcIntraFramerateConversionAlgorithm to be of type string, got %T instead", value) 6492 } 6493 sv.FramerateConversionAlgorithm = types.AvcIntraFramerateConversionAlgorithm(jtv) 6494 } 6495 6496 case "framerateDenominator": 6497 if value != nil { 6498 jtv, ok := value.(json.Number) 6499 if !ok { 6500 return fmt.Errorf("expected __integerMin1Max1001 to be json.Number, got %T instead", value) 6501 } 6502 i64, err := jtv.Int64() 6503 if err != nil { 6504 return err 6505 } 6506 sv.FramerateDenominator = int32(i64) 6507 } 6508 6509 case "framerateNumerator": 6510 if value != nil { 6511 jtv, ok := value.(json.Number) 6512 if !ok { 6513 return fmt.Errorf("expected __integerMin24Max60000 to be json.Number, got %T instead", value) 6514 } 6515 i64, err := jtv.Int64() 6516 if err != nil { 6517 return err 6518 } 6519 sv.FramerateNumerator = int32(i64) 6520 } 6521 6522 case "interlaceMode": 6523 if value != nil { 6524 jtv, ok := value.(string) 6525 if !ok { 6526 return fmt.Errorf("expected AvcIntraInterlaceMode to be of type string, got %T instead", value) 6527 } 6528 sv.InterlaceMode = types.AvcIntraInterlaceMode(jtv) 6529 } 6530 6531 case "slowPal": 6532 if value != nil { 6533 jtv, ok := value.(string) 6534 if !ok { 6535 return fmt.Errorf("expected AvcIntraSlowPal to be of type string, got %T instead", value) 6536 } 6537 sv.SlowPal = types.AvcIntraSlowPal(jtv) 6538 } 6539 6540 case "telecine": 6541 if value != nil { 6542 jtv, ok := value.(string) 6543 if !ok { 6544 return fmt.Errorf("expected AvcIntraTelecine to be of type string, got %T instead", value) 6545 } 6546 sv.Telecine = types.AvcIntraTelecine(jtv) 6547 } 6548 6549 default: 6550 _, _ = key, value 6551 6552 } 6553 } 6554 *v = sv 6555 return nil 6556} 6557 6558func awsRestjson1_deserializeDocumentBadRequestException(v **types.BadRequestException, value interface{}) error { 6559 if v == nil { 6560 return fmt.Errorf("unexpected nil of type %T", v) 6561 } 6562 if value == nil { 6563 return nil 6564 } 6565 6566 shape, ok := value.(map[string]interface{}) 6567 if !ok { 6568 return fmt.Errorf("unexpected JSON type %v", value) 6569 } 6570 6571 var sv *types.BadRequestException 6572 if *v == nil { 6573 sv = &types.BadRequestException{} 6574 } else { 6575 sv = *v 6576 } 6577 6578 for key, value := range shape { 6579 switch key { 6580 case "message": 6581 if value != nil { 6582 jtv, ok := value.(string) 6583 if !ok { 6584 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 6585 } 6586 sv.Message = ptr.String(jtv) 6587 } 6588 6589 default: 6590 _, _ = key, value 6591 6592 } 6593 } 6594 *v = sv 6595 return nil 6596} 6597 6598func awsRestjson1_deserializeDocumentBurninDestinationSettings(v **types.BurninDestinationSettings, value interface{}) error { 6599 if v == nil { 6600 return fmt.Errorf("unexpected nil of type %T", v) 6601 } 6602 if value == nil { 6603 return nil 6604 } 6605 6606 shape, ok := value.(map[string]interface{}) 6607 if !ok { 6608 return fmt.Errorf("unexpected JSON type %v", value) 6609 } 6610 6611 var sv *types.BurninDestinationSettings 6612 if *v == nil { 6613 sv = &types.BurninDestinationSettings{} 6614 } else { 6615 sv = *v 6616 } 6617 6618 for key, value := range shape { 6619 switch key { 6620 case "alignment": 6621 if value != nil { 6622 jtv, ok := value.(string) 6623 if !ok { 6624 return fmt.Errorf("expected BurninSubtitleAlignment to be of type string, got %T instead", value) 6625 } 6626 sv.Alignment = types.BurninSubtitleAlignment(jtv) 6627 } 6628 6629 case "backgroundColor": 6630 if value != nil { 6631 jtv, ok := value.(string) 6632 if !ok { 6633 return fmt.Errorf("expected BurninSubtitleBackgroundColor to be of type string, got %T instead", value) 6634 } 6635 sv.BackgroundColor = types.BurninSubtitleBackgroundColor(jtv) 6636 } 6637 6638 case "backgroundOpacity": 6639 if value != nil { 6640 jtv, ok := value.(json.Number) 6641 if !ok { 6642 return fmt.Errorf("expected __integerMin0Max255 to be json.Number, got %T instead", value) 6643 } 6644 i64, err := jtv.Int64() 6645 if err != nil { 6646 return err 6647 } 6648 sv.BackgroundOpacity = int32(i64) 6649 } 6650 6651 case "fontColor": 6652 if value != nil { 6653 jtv, ok := value.(string) 6654 if !ok { 6655 return fmt.Errorf("expected BurninSubtitleFontColor to be of type string, got %T instead", value) 6656 } 6657 sv.FontColor = types.BurninSubtitleFontColor(jtv) 6658 } 6659 6660 case "fontOpacity": 6661 if value != nil { 6662 jtv, ok := value.(json.Number) 6663 if !ok { 6664 return fmt.Errorf("expected __integerMin0Max255 to be json.Number, got %T instead", value) 6665 } 6666 i64, err := jtv.Int64() 6667 if err != nil { 6668 return err 6669 } 6670 sv.FontOpacity = int32(i64) 6671 } 6672 6673 case "fontResolution": 6674 if value != nil { 6675 jtv, ok := value.(json.Number) 6676 if !ok { 6677 return fmt.Errorf("expected __integerMin96Max600 to be json.Number, got %T instead", value) 6678 } 6679 i64, err := jtv.Int64() 6680 if err != nil { 6681 return err 6682 } 6683 sv.FontResolution = int32(i64) 6684 } 6685 6686 case "fontScript": 6687 if value != nil { 6688 jtv, ok := value.(string) 6689 if !ok { 6690 return fmt.Errorf("expected FontScript to be of type string, got %T instead", value) 6691 } 6692 sv.FontScript = types.FontScript(jtv) 6693 } 6694 6695 case "fontSize": 6696 if value != nil { 6697 jtv, ok := value.(json.Number) 6698 if !ok { 6699 return fmt.Errorf("expected __integerMin0Max96 to be json.Number, got %T instead", value) 6700 } 6701 i64, err := jtv.Int64() 6702 if err != nil { 6703 return err 6704 } 6705 sv.FontSize = int32(i64) 6706 } 6707 6708 case "outlineColor": 6709 if value != nil { 6710 jtv, ok := value.(string) 6711 if !ok { 6712 return fmt.Errorf("expected BurninSubtitleOutlineColor to be of type string, got %T instead", value) 6713 } 6714 sv.OutlineColor = types.BurninSubtitleOutlineColor(jtv) 6715 } 6716 6717 case "outlineSize": 6718 if value != nil { 6719 jtv, ok := value.(json.Number) 6720 if !ok { 6721 return fmt.Errorf("expected __integerMin0Max10 to be json.Number, got %T instead", value) 6722 } 6723 i64, err := jtv.Int64() 6724 if err != nil { 6725 return err 6726 } 6727 sv.OutlineSize = int32(i64) 6728 } 6729 6730 case "shadowColor": 6731 if value != nil { 6732 jtv, ok := value.(string) 6733 if !ok { 6734 return fmt.Errorf("expected BurninSubtitleShadowColor to be of type string, got %T instead", value) 6735 } 6736 sv.ShadowColor = types.BurninSubtitleShadowColor(jtv) 6737 } 6738 6739 case "shadowOpacity": 6740 if value != nil { 6741 jtv, ok := value.(json.Number) 6742 if !ok { 6743 return fmt.Errorf("expected __integerMin0Max255 to be json.Number, got %T instead", value) 6744 } 6745 i64, err := jtv.Int64() 6746 if err != nil { 6747 return err 6748 } 6749 sv.ShadowOpacity = int32(i64) 6750 } 6751 6752 case "shadowXOffset": 6753 if value != nil { 6754 jtv, ok := value.(json.Number) 6755 if !ok { 6756 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 6757 } 6758 i64, err := jtv.Int64() 6759 if err != nil { 6760 return err 6761 } 6762 sv.ShadowXOffset = int32(i64) 6763 } 6764 6765 case "shadowYOffset": 6766 if value != nil { 6767 jtv, ok := value.(json.Number) 6768 if !ok { 6769 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 6770 } 6771 i64, err := jtv.Int64() 6772 if err != nil { 6773 return err 6774 } 6775 sv.ShadowYOffset = int32(i64) 6776 } 6777 6778 case "teletextSpacing": 6779 if value != nil { 6780 jtv, ok := value.(string) 6781 if !ok { 6782 return fmt.Errorf("expected BurninSubtitleTeletextSpacing to be of type string, got %T instead", value) 6783 } 6784 sv.TeletextSpacing = types.BurninSubtitleTeletextSpacing(jtv) 6785 } 6786 6787 case "xPosition": 6788 if value != nil { 6789 jtv, ok := value.(json.Number) 6790 if !ok { 6791 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 6792 } 6793 i64, err := jtv.Int64() 6794 if err != nil { 6795 return err 6796 } 6797 sv.XPosition = int32(i64) 6798 } 6799 6800 case "yPosition": 6801 if value != nil { 6802 jtv, ok := value.(json.Number) 6803 if !ok { 6804 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 6805 } 6806 i64, err := jtv.Int64() 6807 if err != nil { 6808 return err 6809 } 6810 sv.YPosition = int32(i64) 6811 } 6812 6813 default: 6814 _, _ = key, value 6815 6816 } 6817 } 6818 *v = sv 6819 return nil 6820} 6821 6822func awsRestjson1_deserializeDocumentCaptionDescription(v **types.CaptionDescription, value interface{}) error { 6823 if v == nil { 6824 return fmt.Errorf("unexpected nil of type %T", v) 6825 } 6826 if value == nil { 6827 return nil 6828 } 6829 6830 shape, ok := value.(map[string]interface{}) 6831 if !ok { 6832 return fmt.Errorf("unexpected JSON type %v", value) 6833 } 6834 6835 var sv *types.CaptionDescription 6836 if *v == nil { 6837 sv = &types.CaptionDescription{} 6838 } else { 6839 sv = *v 6840 } 6841 6842 for key, value := range shape { 6843 switch key { 6844 case "captionSelectorName": 6845 if value != nil { 6846 jtv, ok := value.(string) 6847 if !ok { 6848 return fmt.Errorf("expected __stringMin1 to be of type string, got %T instead", value) 6849 } 6850 sv.CaptionSelectorName = ptr.String(jtv) 6851 } 6852 6853 case "customLanguageCode": 6854 if value != nil { 6855 jtv, ok := value.(string) 6856 if !ok { 6857 return fmt.Errorf("expected __stringPatternAZaZ23AZaZ to be of type string, got %T instead", value) 6858 } 6859 sv.CustomLanguageCode = ptr.String(jtv) 6860 } 6861 6862 case "destinationSettings": 6863 if err := awsRestjson1_deserializeDocumentCaptionDestinationSettings(&sv.DestinationSettings, value); err != nil { 6864 return err 6865 } 6866 6867 case "languageCode": 6868 if value != nil { 6869 jtv, ok := value.(string) 6870 if !ok { 6871 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 6872 } 6873 sv.LanguageCode = types.LanguageCode(jtv) 6874 } 6875 6876 case "languageDescription": 6877 if value != nil { 6878 jtv, ok := value.(string) 6879 if !ok { 6880 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 6881 } 6882 sv.LanguageDescription = ptr.String(jtv) 6883 } 6884 6885 default: 6886 _, _ = key, value 6887 6888 } 6889 } 6890 *v = sv 6891 return nil 6892} 6893 6894func awsRestjson1_deserializeDocumentCaptionDescriptionPreset(v **types.CaptionDescriptionPreset, value interface{}) error { 6895 if v == nil { 6896 return fmt.Errorf("unexpected nil of type %T", v) 6897 } 6898 if value == nil { 6899 return nil 6900 } 6901 6902 shape, ok := value.(map[string]interface{}) 6903 if !ok { 6904 return fmt.Errorf("unexpected JSON type %v", value) 6905 } 6906 6907 var sv *types.CaptionDescriptionPreset 6908 if *v == nil { 6909 sv = &types.CaptionDescriptionPreset{} 6910 } else { 6911 sv = *v 6912 } 6913 6914 for key, value := range shape { 6915 switch key { 6916 case "customLanguageCode": 6917 if value != nil { 6918 jtv, ok := value.(string) 6919 if !ok { 6920 return fmt.Errorf("expected __stringPatternAZaZ23AZaZ to be of type string, got %T instead", value) 6921 } 6922 sv.CustomLanguageCode = ptr.String(jtv) 6923 } 6924 6925 case "destinationSettings": 6926 if err := awsRestjson1_deserializeDocumentCaptionDestinationSettings(&sv.DestinationSettings, value); err != nil { 6927 return err 6928 } 6929 6930 case "languageCode": 6931 if value != nil { 6932 jtv, ok := value.(string) 6933 if !ok { 6934 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 6935 } 6936 sv.LanguageCode = types.LanguageCode(jtv) 6937 } 6938 6939 case "languageDescription": 6940 if value != nil { 6941 jtv, ok := value.(string) 6942 if !ok { 6943 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 6944 } 6945 sv.LanguageDescription = ptr.String(jtv) 6946 } 6947 6948 default: 6949 _, _ = key, value 6950 6951 } 6952 } 6953 *v = sv 6954 return nil 6955} 6956 6957func awsRestjson1_deserializeDocumentCaptionDestinationSettings(v **types.CaptionDestinationSettings, value interface{}) error { 6958 if v == nil { 6959 return fmt.Errorf("unexpected nil of type %T", v) 6960 } 6961 if value == nil { 6962 return nil 6963 } 6964 6965 shape, ok := value.(map[string]interface{}) 6966 if !ok { 6967 return fmt.Errorf("unexpected JSON type %v", value) 6968 } 6969 6970 var sv *types.CaptionDestinationSettings 6971 if *v == nil { 6972 sv = &types.CaptionDestinationSettings{} 6973 } else { 6974 sv = *v 6975 } 6976 6977 for key, value := range shape { 6978 switch key { 6979 case "burninDestinationSettings": 6980 if err := awsRestjson1_deserializeDocumentBurninDestinationSettings(&sv.BurninDestinationSettings, value); err != nil { 6981 return err 6982 } 6983 6984 case "destinationType": 6985 if value != nil { 6986 jtv, ok := value.(string) 6987 if !ok { 6988 return fmt.Errorf("expected CaptionDestinationType to be of type string, got %T instead", value) 6989 } 6990 sv.DestinationType = types.CaptionDestinationType(jtv) 6991 } 6992 6993 case "dvbSubDestinationSettings": 6994 if err := awsRestjson1_deserializeDocumentDvbSubDestinationSettings(&sv.DvbSubDestinationSettings, value); err != nil { 6995 return err 6996 } 6997 6998 case "embeddedDestinationSettings": 6999 if err := awsRestjson1_deserializeDocumentEmbeddedDestinationSettings(&sv.EmbeddedDestinationSettings, value); err != nil { 7000 return err 7001 } 7002 7003 case "imscDestinationSettings": 7004 if err := awsRestjson1_deserializeDocumentImscDestinationSettings(&sv.ImscDestinationSettings, value); err != nil { 7005 return err 7006 } 7007 7008 case "sccDestinationSettings": 7009 if err := awsRestjson1_deserializeDocumentSccDestinationSettings(&sv.SccDestinationSettings, value); err != nil { 7010 return err 7011 } 7012 7013 case "teletextDestinationSettings": 7014 if err := awsRestjson1_deserializeDocumentTeletextDestinationSettings(&sv.TeletextDestinationSettings, value); err != nil { 7015 return err 7016 } 7017 7018 case "ttmlDestinationSettings": 7019 if err := awsRestjson1_deserializeDocumentTtmlDestinationSettings(&sv.TtmlDestinationSettings, value); err != nil { 7020 return err 7021 } 7022 7023 default: 7024 _, _ = key, value 7025 7026 } 7027 } 7028 *v = sv 7029 return nil 7030} 7031 7032func awsRestjson1_deserializeDocumentCaptionSelector(v **types.CaptionSelector, value interface{}) error { 7033 if v == nil { 7034 return fmt.Errorf("unexpected nil of type %T", v) 7035 } 7036 if value == nil { 7037 return nil 7038 } 7039 7040 shape, ok := value.(map[string]interface{}) 7041 if !ok { 7042 return fmt.Errorf("unexpected JSON type %v", value) 7043 } 7044 7045 var sv *types.CaptionSelector 7046 if *v == nil { 7047 sv = &types.CaptionSelector{} 7048 } else { 7049 sv = *v 7050 } 7051 7052 for key, value := range shape { 7053 switch key { 7054 case "customLanguageCode": 7055 if value != nil { 7056 jtv, ok := value.(string) 7057 if !ok { 7058 return fmt.Errorf("expected __stringMin3Max3PatternAZaZ3 to be of type string, got %T instead", value) 7059 } 7060 sv.CustomLanguageCode = ptr.String(jtv) 7061 } 7062 7063 case "languageCode": 7064 if value != nil { 7065 jtv, ok := value.(string) 7066 if !ok { 7067 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 7068 } 7069 sv.LanguageCode = types.LanguageCode(jtv) 7070 } 7071 7072 case "sourceSettings": 7073 if err := awsRestjson1_deserializeDocumentCaptionSourceSettings(&sv.SourceSettings, value); err != nil { 7074 return err 7075 } 7076 7077 default: 7078 _, _ = key, value 7079 7080 } 7081 } 7082 *v = sv 7083 return nil 7084} 7085 7086func awsRestjson1_deserializeDocumentCaptionSourceFramerate(v **types.CaptionSourceFramerate, value interface{}) error { 7087 if v == nil { 7088 return fmt.Errorf("unexpected nil of type %T", v) 7089 } 7090 if value == nil { 7091 return nil 7092 } 7093 7094 shape, ok := value.(map[string]interface{}) 7095 if !ok { 7096 return fmt.Errorf("unexpected JSON type %v", value) 7097 } 7098 7099 var sv *types.CaptionSourceFramerate 7100 if *v == nil { 7101 sv = &types.CaptionSourceFramerate{} 7102 } else { 7103 sv = *v 7104 } 7105 7106 for key, value := range shape { 7107 switch key { 7108 case "framerateDenominator": 7109 if value != nil { 7110 jtv, ok := value.(json.Number) 7111 if !ok { 7112 return fmt.Errorf("expected __integerMin1Max1001 to be json.Number, got %T instead", value) 7113 } 7114 i64, err := jtv.Int64() 7115 if err != nil { 7116 return err 7117 } 7118 sv.FramerateDenominator = int32(i64) 7119 } 7120 7121 case "framerateNumerator": 7122 if value != nil { 7123 jtv, ok := value.(json.Number) 7124 if !ok { 7125 return fmt.Errorf("expected __integerMin1Max60000 to be json.Number, got %T instead", value) 7126 } 7127 i64, err := jtv.Int64() 7128 if err != nil { 7129 return err 7130 } 7131 sv.FramerateNumerator = int32(i64) 7132 } 7133 7134 default: 7135 _, _ = key, value 7136 7137 } 7138 } 7139 *v = sv 7140 return nil 7141} 7142 7143func awsRestjson1_deserializeDocumentCaptionSourceSettings(v **types.CaptionSourceSettings, value interface{}) error { 7144 if v == nil { 7145 return fmt.Errorf("unexpected nil of type %T", v) 7146 } 7147 if value == nil { 7148 return nil 7149 } 7150 7151 shape, ok := value.(map[string]interface{}) 7152 if !ok { 7153 return fmt.Errorf("unexpected JSON type %v", value) 7154 } 7155 7156 var sv *types.CaptionSourceSettings 7157 if *v == nil { 7158 sv = &types.CaptionSourceSettings{} 7159 } else { 7160 sv = *v 7161 } 7162 7163 for key, value := range shape { 7164 switch key { 7165 case "ancillarySourceSettings": 7166 if err := awsRestjson1_deserializeDocumentAncillarySourceSettings(&sv.AncillarySourceSettings, value); err != nil { 7167 return err 7168 } 7169 7170 case "dvbSubSourceSettings": 7171 if err := awsRestjson1_deserializeDocumentDvbSubSourceSettings(&sv.DvbSubSourceSettings, value); err != nil { 7172 return err 7173 } 7174 7175 case "embeddedSourceSettings": 7176 if err := awsRestjson1_deserializeDocumentEmbeddedSourceSettings(&sv.EmbeddedSourceSettings, value); err != nil { 7177 return err 7178 } 7179 7180 case "fileSourceSettings": 7181 if err := awsRestjson1_deserializeDocumentFileSourceSettings(&sv.FileSourceSettings, value); err != nil { 7182 return err 7183 } 7184 7185 case "sourceType": 7186 if value != nil { 7187 jtv, ok := value.(string) 7188 if !ok { 7189 return fmt.Errorf("expected CaptionSourceType to be of type string, got %T instead", value) 7190 } 7191 sv.SourceType = types.CaptionSourceType(jtv) 7192 } 7193 7194 case "teletextSourceSettings": 7195 if err := awsRestjson1_deserializeDocumentTeletextSourceSettings(&sv.TeletextSourceSettings, value); err != nil { 7196 return err 7197 } 7198 7199 case "trackSourceSettings": 7200 if err := awsRestjson1_deserializeDocumentTrackSourceSettings(&sv.TrackSourceSettings, value); err != nil { 7201 return err 7202 } 7203 7204 default: 7205 _, _ = key, value 7206 7207 } 7208 } 7209 *v = sv 7210 return nil 7211} 7212 7213func awsRestjson1_deserializeDocumentChannelMapping(v **types.ChannelMapping, value interface{}) error { 7214 if v == nil { 7215 return fmt.Errorf("unexpected nil of type %T", v) 7216 } 7217 if value == nil { 7218 return nil 7219 } 7220 7221 shape, ok := value.(map[string]interface{}) 7222 if !ok { 7223 return fmt.Errorf("unexpected JSON type %v", value) 7224 } 7225 7226 var sv *types.ChannelMapping 7227 if *v == nil { 7228 sv = &types.ChannelMapping{} 7229 } else { 7230 sv = *v 7231 } 7232 7233 for key, value := range shape { 7234 switch key { 7235 case "outputChannels": 7236 if err := awsRestjson1_deserializeDocument__listOfOutputChannelMapping(&sv.OutputChannels, value); err != nil { 7237 return err 7238 } 7239 7240 default: 7241 _, _ = key, value 7242 7243 } 7244 } 7245 *v = sv 7246 return nil 7247} 7248 7249func awsRestjson1_deserializeDocumentCmafAdditionalManifest(v **types.CmafAdditionalManifest, value interface{}) error { 7250 if v == nil { 7251 return fmt.Errorf("unexpected nil of type %T", v) 7252 } 7253 if value == nil { 7254 return nil 7255 } 7256 7257 shape, ok := value.(map[string]interface{}) 7258 if !ok { 7259 return fmt.Errorf("unexpected JSON type %v", value) 7260 } 7261 7262 var sv *types.CmafAdditionalManifest 7263 if *v == nil { 7264 sv = &types.CmafAdditionalManifest{} 7265 } else { 7266 sv = *v 7267 } 7268 7269 for key, value := range shape { 7270 switch key { 7271 case "manifestNameModifier": 7272 if value != nil { 7273 jtv, ok := value.(string) 7274 if !ok { 7275 return fmt.Errorf("expected __stringMin1 to be of type string, got %T instead", value) 7276 } 7277 sv.ManifestNameModifier = ptr.String(jtv) 7278 } 7279 7280 case "selectedOutputs": 7281 if err := awsRestjson1_deserializeDocument__listOf__stringMin1(&sv.SelectedOutputs, value); err != nil { 7282 return err 7283 } 7284 7285 default: 7286 _, _ = key, value 7287 7288 } 7289 } 7290 *v = sv 7291 return nil 7292} 7293 7294func awsRestjson1_deserializeDocumentCmafEncryptionSettings(v **types.CmafEncryptionSettings, value interface{}) error { 7295 if v == nil { 7296 return fmt.Errorf("unexpected nil of type %T", v) 7297 } 7298 if value == nil { 7299 return nil 7300 } 7301 7302 shape, ok := value.(map[string]interface{}) 7303 if !ok { 7304 return fmt.Errorf("unexpected JSON type %v", value) 7305 } 7306 7307 var sv *types.CmafEncryptionSettings 7308 if *v == nil { 7309 sv = &types.CmafEncryptionSettings{} 7310 } else { 7311 sv = *v 7312 } 7313 7314 for key, value := range shape { 7315 switch key { 7316 case "constantInitializationVector": 7317 if value != nil { 7318 jtv, ok := value.(string) 7319 if !ok { 7320 return fmt.Errorf("expected __stringMin32Max32Pattern09aFAF32 to be of type string, got %T instead", value) 7321 } 7322 sv.ConstantInitializationVector = ptr.String(jtv) 7323 } 7324 7325 case "encryptionMethod": 7326 if value != nil { 7327 jtv, ok := value.(string) 7328 if !ok { 7329 return fmt.Errorf("expected CmafEncryptionType to be of type string, got %T instead", value) 7330 } 7331 sv.EncryptionMethod = types.CmafEncryptionType(jtv) 7332 } 7333 7334 case "initializationVectorInManifest": 7335 if value != nil { 7336 jtv, ok := value.(string) 7337 if !ok { 7338 return fmt.Errorf("expected CmafInitializationVectorInManifest to be of type string, got %T instead", value) 7339 } 7340 sv.InitializationVectorInManifest = types.CmafInitializationVectorInManifest(jtv) 7341 } 7342 7343 case "spekeKeyProvider": 7344 if err := awsRestjson1_deserializeDocumentSpekeKeyProviderCmaf(&sv.SpekeKeyProvider, value); err != nil { 7345 return err 7346 } 7347 7348 case "staticKeyProvider": 7349 if err := awsRestjson1_deserializeDocumentStaticKeyProvider(&sv.StaticKeyProvider, value); err != nil { 7350 return err 7351 } 7352 7353 case "type": 7354 if value != nil { 7355 jtv, ok := value.(string) 7356 if !ok { 7357 return fmt.Errorf("expected CmafKeyProviderType to be of type string, got %T instead", value) 7358 } 7359 sv.Type = types.CmafKeyProviderType(jtv) 7360 } 7361 7362 default: 7363 _, _ = key, value 7364 7365 } 7366 } 7367 *v = sv 7368 return nil 7369} 7370 7371func awsRestjson1_deserializeDocumentCmafGroupSettings(v **types.CmafGroupSettings, value interface{}) error { 7372 if v == nil { 7373 return fmt.Errorf("unexpected nil of type %T", v) 7374 } 7375 if value == nil { 7376 return nil 7377 } 7378 7379 shape, ok := value.(map[string]interface{}) 7380 if !ok { 7381 return fmt.Errorf("unexpected JSON type %v", value) 7382 } 7383 7384 var sv *types.CmafGroupSettings 7385 if *v == nil { 7386 sv = &types.CmafGroupSettings{} 7387 } else { 7388 sv = *v 7389 } 7390 7391 for key, value := range shape { 7392 switch key { 7393 case "additionalManifests": 7394 if err := awsRestjson1_deserializeDocument__listOfCmafAdditionalManifest(&sv.AdditionalManifests, value); err != nil { 7395 return err 7396 } 7397 7398 case "baseUrl": 7399 if value != nil { 7400 jtv, ok := value.(string) 7401 if !ok { 7402 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 7403 } 7404 sv.BaseUrl = ptr.String(jtv) 7405 } 7406 7407 case "clientCache": 7408 if value != nil { 7409 jtv, ok := value.(string) 7410 if !ok { 7411 return fmt.Errorf("expected CmafClientCache to be of type string, got %T instead", value) 7412 } 7413 sv.ClientCache = types.CmafClientCache(jtv) 7414 } 7415 7416 case "codecSpecification": 7417 if value != nil { 7418 jtv, ok := value.(string) 7419 if !ok { 7420 return fmt.Errorf("expected CmafCodecSpecification to be of type string, got %T instead", value) 7421 } 7422 sv.CodecSpecification = types.CmafCodecSpecification(jtv) 7423 } 7424 7425 case "destination": 7426 if value != nil { 7427 jtv, ok := value.(string) 7428 if !ok { 7429 return fmt.Errorf("expected __stringPatternS3 to be of type string, got %T instead", value) 7430 } 7431 sv.Destination = ptr.String(jtv) 7432 } 7433 7434 case "destinationSettings": 7435 if err := awsRestjson1_deserializeDocumentDestinationSettings(&sv.DestinationSettings, value); err != nil { 7436 return err 7437 } 7438 7439 case "encryption": 7440 if err := awsRestjson1_deserializeDocumentCmafEncryptionSettings(&sv.Encryption, value); err != nil { 7441 return err 7442 } 7443 7444 case "fragmentLength": 7445 if value != nil { 7446 jtv, ok := value.(json.Number) 7447 if !ok { 7448 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 7449 } 7450 i64, err := jtv.Int64() 7451 if err != nil { 7452 return err 7453 } 7454 sv.FragmentLength = int32(i64) 7455 } 7456 7457 case "manifestCompression": 7458 if value != nil { 7459 jtv, ok := value.(string) 7460 if !ok { 7461 return fmt.Errorf("expected CmafManifestCompression to be of type string, got %T instead", value) 7462 } 7463 sv.ManifestCompression = types.CmafManifestCompression(jtv) 7464 } 7465 7466 case "manifestDurationFormat": 7467 if value != nil { 7468 jtv, ok := value.(string) 7469 if !ok { 7470 return fmt.Errorf("expected CmafManifestDurationFormat to be of type string, got %T instead", value) 7471 } 7472 sv.ManifestDurationFormat = types.CmafManifestDurationFormat(jtv) 7473 } 7474 7475 case "minBufferTime": 7476 if value != nil { 7477 jtv, ok := value.(json.Number) 7478 if !ok { 7479 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 7480 } 7481 i64, err := jtv.Int64() 7482 if err != nil { 7483 return err 7484 } 7485 sv.MinBufferTime = int32(i64) 7486 } 7487 7488 case "minFinalSegmentLength": 7489 if value != nil { 7490 jtv, ok := value.(json.Number) 7491 if !ok { 7492 return fmt.Errorf("expected __doubleMin0Max2147483647 to be json.Number, got %T instead", value) 7493 } 7494 f64, err := jtv.Float64() 7495 if err != nil { 7496 return err 7497 } 7498 sv.MinFinalSegmentLength = f64 7499 } 7500 7501 case "mpdProfile": 7502 if value != nil { 7503 jtv, ok := value.(string) 7504 if !ok { 7505 return fmt.Errorf("expected CmafMpdProfile to be of type string, got %T instead", value) 7506 } 7507 sv.MpdProfile = types.CmafMpdProfile(jtv) 7508 } 7509 7510 case "segmentControl": 7511 if value != nil { 7512 jtv, ok := value.(string) 7513 if !ok { 7514 return fmt.Errorf("expected CmafSegmentControl to be of type string, got %T instead", value) 7515 } 7516 sv.SegmentControl = types.CmafSegmentControl(jtv) 7517 } 7518 7519 case "segmentLength": 7520 if value != nil { 7521 jtv, ok := value.(json.Number) 7522 if !ok { 7523 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 7524 } 7525 i64, err := jtv.Int64() 7526 if err != nil { 7527 return err 7528 } 7529 sv.SegmentLength = int32(i64) 7530 } 7531 7532 case "streamInfResolution": 7533 if value != nil { 7534 jtv, ok := value.(string) 7535 if !ok { 7536 return fmt.Errorf("expected CmafStreamInfResolution to be of type string, got %T instead", value) 7537 } 7538 sv.StreamInfResolution = types.CmafStreamInfResolution(jtv) 7539 } 7540 7541 case "writeDashManifest": 7542 if value != nil { 7543 jtv, ok := value.(string) 7544 if !ok { 7545 return fmt.Errorf("expected CmafWriteDASHManifest to be of type string, got %T instead", value) 7546 } 7547 sv.WriteDashManifest = types.CmafWriteDASHManifest(jtv) 7548 } 7549 7550 case "writeHlsManifest": 7551 if value != nil { 7552 jtv, ok := value.(string) 7553 if !ok { 7554 return fmt.Errorf("expected CmafWriteHLSManifest to be of type string, got %T instead", value) 7555 } 7556 sv.WriteHlsManifest = types.CmafWriteHLSManifest(jtv) 7557 } 7558 7559 case "writeSegmentTimelineInRepresentation": 7560 if value != nil { 7561 jtv, ok := value.(string) 7562 if !ok { 7563 return fmt.Errorf("expected CmafWriteSegmentTimelineInRepresentation to be of type string, got %T instead", value) 7564 } 7565 sv.WriteSegmentTimelineInRepresentation = types.CmafWriteSegmentTimelineInRepresentation(jtv) 7566 } 7567 7568 default: 7569 _, _ = key, value 7570 7571 } 7572 } 7573 *v = sv 7574 return nil 7575} 7576 7577func awsRestjson1_deserializeDocumentCmfcSettings(v **types.CmfcSettings, value interface{}) error { 7578 if v == nil { 7579 return fmt.Errorf("unexpected nil of type %T", v) 7580 } 7581 if value == nil { 7582 return nil 7583 } 7584 7585 shape, ok := value.(map[string]interface{}) 7586 if !ok { 7587 return fmt.Errorf("unexpected JSON type %v", value) 7588 } 7589 7590 var sv *types.CmfcSettings 7591 if *v == nil { 7592 sv = &types.CmfcSettings{} 7593 } else { 7594 sv = *v 7595 } 7596 7597 for key, value := range shape { 7598 switch key { 7599 case "audioDuration": 7600 if value != nil { 7601 jtv, ok := value.(string) 7602 if !ok { 7603 return fmt.Errorf("expected CmfcAudioDuration to be of type string, got %T instead", value) 7604 } 7605 sv.AudioDuration = types.CmfcAudioDuration(jtv) 7606 } 7607 7608 case "scte35Esam": 7609 if value != nil { 7610 jtv, ok := value.(string) 7611 if !ok { 7612 return fmt.Errorf("expected CmfcScte35Esam to be of type string, got %T instead", value) 7613 } 7614 sv.Scte35Esam = types.CmfcScte35Esam(jtv) 7615 } 7616 7617 case "scte35Source": 7618 if value != nil { 7619 jtv, ok := value.(string) 7620 if !ok { 7621 return fmt.Errorf("expected CmfcScte35Source to be of type string, got %T instead", value) 7622 } 7623 sv.Scte35Source = types.CmfcScte35Source(jtv) 7624 } 7625 7626 default: 7627 _, _ = key, value 7628 7629 } 7630 } 7631 *v = sv 7632 return nil 7633} 7634 7635func awsRestjson1_deserializeDocumentColorCorrector(v **types.ColorCorrector, value interface{}) error { 7636 if v == nil { 7637 return fmt.Errorf("unexpected nil of type %T", v) 7638 } 7639 if value == nil { 7640 return nil 7641 } 7642 7643 shape, ok := value.(map[string]interface{}) 7644 if !ok { 7645 return fmt.Errorf("unexpected JSON type %v", value) 7646 } 7647 7648 var sv *types.ColorCorrector 7649 if *v == nil { 7650 sv = &types.ColorCorrector{} 7651 } else { 7652 sv = *v 7653 } 7654 7655 for key, value := range shape { 7656 switch key { 7657 case "brightness": 7658 if value != nil { 7659 jtv, ok := value.(json.Number) 7660 if !ok { 7661 return fmt.Errorf("expected __integerMin1Max100 to be json.Number, got %T instead", value) 7662 } 7663 i64, err := jtv.Int64() 7664 if err != nil { 7665 return err 7666 } 7667 sv.Brightness = int32(i64) 7668 } 7669 7670 case "colorSpaceConversion": 7671 if value != nil { 7672 jtv, ok := value.(string) 7673 if !ok { 7674 return fmt.Errorf("expected ColorSpaceConversion to be of type string, got %T instead", value) 7675 } 7676 sv.ColorSpaceConversion = types.ColorSpaceConversion(jtv) 7677 } 7678 7679 case "contrast": 7680 if value != nil { 7681 jtv, ok := value.(json.Number) 7682 if !ok { 7683 return fmt.Errorf("expected __integerMin1Max100 to be json.Number, got %T instead", value) 7684 } 7685 i64, err := jtv.Int64() 7686 if err != nil { 7687 return err 7688 } 7689 sv.Contrast = int32(i64) 7690 } 7691 7692 case "hdr10Metadata": 7693 if err := awsRestjson1_deserializeDocumentHdr10Metadata(&sv.Hdr10Metadata, value); err != nil { 7694 return err 7695 } 7696 7697 case "hue": 7698 if value != nil { 7699 jtv, ok := value.(json.Number) 7700 if !ok { 7701 return fmt.Errorf("expected __integerMinNegative180Max180 to be json.Number, got %T instead", value) 7702 } 7703 i64, err := jtv.Int64() 7704 if err != nil { 7705 return err 7706 } 7707 sv.Hue = int32(i64) 7708 } 7709 7710 case "saturation": 7711 if value != nil { 7712 jtv, ok := value.(json.Number) 7713 if !ok { 7714 return fmt.Errorf("expected __integerMin1Max100 to be json.Number, got %T instead", value) 7715 } 7716 i64, err := jtv.Int64() 7717 if err != nil { 7718 return err 7719 } 7720 sv.Saturation = int32(i64) 7721 } 7722 7723 default: 7724 _, _ = key, value 7725 7726 } 7727 } 7728 *v = sv 7729 return nil 7730} 7731 7732func awsRestjson1_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { 7733 if v == nil { 7734 return fmt.Errorf("unexpected nil of type %T", v) 7735 } 7736 if value == nil { 7737 return nil 7738 } 7739 7740 shape, ok := value.(map[string]interface{}) 7741 if !ok { 7742 return fmt.Errorf("unexpected JSON type %v", value) 7743 } 7744 7745 var sv *types.ConflictException 7746 if *v == nil { 7747 sv = &types.ConflictException{} 7748 } else { 7749 sv = *v 7750 } 7751 7752 for key, value := range shape { 7753 switch key { 7754 case "message": 7755 if value != nil { 7756 jtv, ok := value.(string) 7757 if !ok { 7758 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 7759 } 7760 sv.Message = ptr.String(jtv) 7761 } 7762 7763 default: 7764 _, _ = key, value 7765 7766 } 7767 } 7768 *v = sv 7769 return nil 7770} 7771 7772func awsRestjson1_deserializeDocumentContainerSettings(v **types.ContainerSettings, value interface{}) error { 7773 if v == nil { 7774 return fmt.Errorf("unexpected nil of type %T", v) 7775 } 7776 if value == nil { 7777 return nil 7778 } 7779 7780 shape, ok := value.(map[string]interface{}) 7781 if !ok { 7782 return fmt.Errorf("unexpected JSON type %v", value) 7783 } 7784 7785 var sv *types.ContainerSettings 7786 if *v == nil { 7787 sv = &types.ContainerSettings{} 7788 } else { 7789 sv = *v 7790 } 7791 7792 for key, value := range shape { 7793 switch key { 7794 case "cmfcSettings": 7795 if err := awsRestjson1_deserializeDocumentCmfcSettings(&sv.CmfcSettings, value); err != nil { 7796 return err 7797 } 7798 7799 case "container": 7800 if value != nil { 7801 jtv, ok := value.(string) 7802 if !ok { 7803 return fmt.Errorf("expected ContainerType to be of type string, got %T instead", value) 7804 } 7805 sv.Container = types.ContainerType(jtv) 7806 } 7807 7808 case "f4vSettings": 7809 if err := awsRestjson1_deserializeDocumentF4vSettings(&sv.F4vSettings, value); err != nil { 7810 return err 7811 } 7812 7813 case "m2tsSettings": 7814 if err := awsRestjson1_deserializeDocumentM2tsSettings(&sv.M2tsSettings, value); err != nil { 7815 return err 7816 } 7817 7818 case "m3u8Settings": 7819 if err := awsRestjson1_deserializeDocumentM3u8Settings(&sv.M3u8Settings, value); err != nil { 7820 return err 7821 } 7822 7823 case "movSettings": 7824 if err := awsRestjson1_deserializeDocumentMovSettings(&sv.MovSettings, value); err != nil { 7825 return err 7826 } 7827 7828 case "mp4Settings": 7829 if err := awsRestjson1_deserializeDocumentMp4Settings(&sv.Mp4Settings, value); err != nil { 7830 return err 7831 } 7832 7833 case "mpdSettings": 7834 if err := awsRestjson1_deserializeDocumentMpdSettings(&sv.MpdSettings, value); err != nil { 7835 return err 7836 } 7837 7838 case "mxfSettings": 7839 if err := awsRestjson1_deserializeDocumentMxfSettings(&sv.MxfSettings, value); err != nil { 7840 return err 7841 } 7842 7843 default: 7844 _, _ = key, value 7845 7846 } 7847 } 7848 *v = sv 7849 return nil 7850} 7851 7852func awsRestjson1_deserializeDocumentDashAdditionalManifest(v **types.DashAdditionalManifest, value interface{}) error { 7853 if v == nil { 7854 return fmt.Errorf("unexpected nil of type %T", v) 7855 } 7856 if value == nil { 7857 return nil 7858 } 7859 7860 shape, ok := value.(map[string]interface{}) 7861 if !ok { 7862 return fmt.Errorf("unexpected JSON type %v", value) 7863 } 7864 7865 var sv *types.DashAdditionalManifest 7866 if *v == nil { 7867 sv = &types.DashAdditionalManifest{} 7868 } else { 7869 sv = *v 7870 } 7871 7872 for key, value := range shape { 7873 switch key { 7874 case "manifestNameModifier": 7875 if value != nil { 7876 jtv, ok := value.(string) 7877 if !ok { 7878 return fmt.Errorf("expected __stringMin1 to be of type string, got %T instead", value) 7879 } 7880 sv.ManifestNameModifier = ptr.String(jtv) 7881 } 7882 7883 case "selectedOutputs": 7884 if err := awsRestjson1_deserializeDocument__listOf__stringMin1(&sv.SelectedOutputs, value); err != nil { 7885 return err 7886 } 7887 7888 default: 7889 _, _ = key, value 7890 7891 } 7892 } 7893 *v = sv 7894 return nil 7895} 7896 7897func awsRestjson1_deserializeDocumentDashIsoEncryptionSettings(v **types.DashIsoEncryptionSettings, value interface{}) error { 7898 if v == nil { 7899 return fmt.Errorf("unexpected nil of type %T", v) 7900 } 7901 if value == nil { 7902 return nil 7903 } 7904 7905 shape, ok := value.(map[string]interface{}) 7906 if !ok { 7907 return fmt.Errorf("unexpected JSON type %v", value) 7908 } 7909 7910 var sv *types.DashIsoEncryptionSettings 7911 if *v == nil { 7912 sv = &types.DashIsoEncryptionSettings{} 7913 } else { 7914 sv = *v 7915 } 7916 7917 for key, value := range shape { 7918 switch key { 7919 case "playbackDeviceCompatibility": 7920 if value != nil { 7921 jtv, ok := value.(string) 7922 if !ok { 7923 return fmt.Errorf("expected DashIsoPlaybackDeviceCompatibility to be of type string, got %T instead", value) 7924 } 7925 sv.PlaybackDeviceCompatibility = types.DashIsoPlaybackDeviceCompatibility(jtv) 7926 } 7927 7928 case "spekeKeyProvider": 7929 if err := awsRestjson1_deserializeDocumentSpekeKeyProvider(&sv.SpekeKeyProvider, value); err != nil { 7930 return err 7931 } 7932 7933 default: 7934 _, _ = key, value 7935 7936 } 7937 } 7938 *v = sv 7939 return nil 7940} 7941 7942func awsRestjson1_deserializeDocumentDashIsoGroupSettings(v **types.DashIsoGroupSettings, value interface{}) error { 7943 if v == nil { 7944 return fmt.Errorf("unexpected nil of type %T", v) 7945 } 7946 if value == nil { 7947 return nil 7948 } 7949 7950 shape, ok := value.(map[string]interface{}) 7951 if !ok { 7952 return fmt.Errorf("unexpected JSON type %v", value) 7953 } 7954 7955 var sv *types.DashIsoGroupSettings 7956 if *v == nil { 7957 sv = &types.DashIsoGroupSettings{} 7958 } else { 7959 sv = *v 7960 } 7961 7962 for key, value := range shape { 7963 switch key { 7964 case "additionalManifests": 7965 if err := awsRestjson1_deserializeDocument__listOfDashAdditionalManifest(&sv.AdditionalManifests, value); err != nil { 7966 return err 7967 } 7968 7969 case "baseUrl": 7970 if value != nil { 7971 jtv, ok := value.(string) 7972 if !ok { 7973 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 7974 } 7975 sv.BaseUrl = ptr.String(jtv) 7976 } 7977 7978 case "destination": 7979 if value != nil { 7980 jtv, ok := value.(string) 7981 if !ok { 7982 return fmt.Errorf("expected __stringPatternS3 to be of type string, got %T instead", value) 7983 } 7984 sv.Destination = ptr.String(jtv) 7985 } 7986 7987 case "destinationSettings": 7988 if err := awsRestjson1_deserializeDocumentDestinationSettings(&sv.DestinationSettings, value); err != nil { 7989 return err 7990 } 7991 7992 case "encryption": 7993 if err := awsRestjson1_deserializeDocumentDashIsoEncryptionSettings(&sv.Encryption, value); err != nil { 7994 return err 7995 } 7996 7997 case "fragmentLength": 7998 if value != nil { 7999 jtv, ok := value.(json.Number) 8000 if !ok { 8001 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 8002 } 8003 i64, err := jtv.Int64() 8004 if err != nil { 8005 return err 8006 } 8007 sv.FragmentLength = int32(i64) 8008 } 8009 8010 case "hbbtvCompliance": 8011 if value != nil { 8012 jtv, ok := value.(string) 8013 if !ok { 8014 return fmt.Errorf("expected DashIsoHbbtvCompliance to be of type string, got %T instead", value) 8015 } 8016 sv.HbbtvCompliance = types.DashIsoHbbtvCompliance(jtv) 8017 } 8018 8019 case "minBufferTime": 8020 if value != nil { 8021 jtv, ok := value.(json.Number) 8022 if !ok { 8023 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 8024 } 8025 i64, err := jtv.Int64() 8026 if err != nil { 8027 return err 8028 } 8029 sv.MinBufferTime = int32(i64) 8030 } 8031 8032 case "minFinalSegmentLength": 8033 if value != nil { 8034 jtv, ok := value.(json.Number) 8035 if !ok { 8036 return fmt.Errorf("expected __doubleMin0Max2147483647 to be json.Number, got %T instead", value) 8037 } 8038 f64, err := jtv.Float64() 8039 if err != nil { 8040 return err 8041 } 8042 sv.MinFinalSegmentLength = f64 8043 } 8044 8045 case "mpdProfile": 8046 if value != nil { 8047 jtv, ok := value.(string) 8048 if !ok { 8049 return fmt.Errorf("expected DashIsoMpdProfile to be of type string, got %T instead", value) 8050 } 8051 sv.MpdProfile = types.DashIsoMpdProfile(jtv) 8052 } 8053 8054 case "segmentControl": 8055 if value != nil { 8056 jtv, ok := value.(string) 8057 if !ok { 8058 return fmt.Errorf("expected DashIsoSegmentControl to be of type string, got %T instead", value) 8059 } 8060 sv.SegmentControl = types.DashIsoSegmentControl(jtv) 8061 } 8062 8063 case "segmentLength": 8064 if value != nil { 8065 jtv, ok := value.(json.Number) 8066 if !ok { 8067 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 8068 } 8069 i64, err := jtv.Int64() 8070 if err != nil { 8071 return err 8072 } 8073 sv.SegmentLength = int32(i64) 8074 } 8075 8076 case "writeSegmentTimelineInRepresentation": 8077 if value != nil { 8078 jtv, ok := value.(string) 8079 if !ok { 8080 return fmt.Errorf("expected DashIsoWriteSegmentTimelineInRepresentation to be of type string, got %T instead", value) 8081 } 8082 sv.WriteSegmentTimelineInRepresentation = types.DashIsoWriteSegmentTimelineInRepresentation(jtv) 8083 } 8084 8085 default: 8086 _, _ = key, value 8087 8088 } 8089 } 8090 *v = sv 8091 return nil 8092} 8093 8094func awsRestjson1_deserializeDocumentDeinterlacer(v **types.Deinterlacer, value interface{}) error { 8095 if v == nil { 8096 return fmt.Errorf("unexpected nil of type %T", v) 8097 } 8098 if value == nil { 8099 return nil 8100 } 8101 8102 shape, ok := value.(map[string]interface{}) 8103 if !ok { 8104 return fmt.Errorf("unexpected JSON type %v", value) 8105 } 8106 8107 var sv *types.Deinterlacer 8108 if *v == nil { 8109 sv = &types.Deinterlacer{} 8110 } else { 8111 sv = *v 8112 } 8113 8114 for key, value := range shape { 8115 switch key { 8116 case "algorithm": 8117 if value != nil { 8118 jtv, ok := value.(string) 8119 if !ok { 8120 return fmt.Errorf("expected DeinterlaceAlgorithm to be of type string, got %T instead", value) 8121 } 8122 sv.Algorithm = types.DeinterlaceAlgorithm(jtv) 8123 } 8124 8125 case "control": 8126 if value != nil { 8127 jtv, ok := value.(string) 8128 if !ok { 8129 return fmt.Errorf("expected DeinterlacerControl to be of type string, got %T instead", value) 8130 } 8131 sv.Control = types.DeinterlacerControl(jtv) 8132 } 8133 8134 case "mode": 8135 if value != nil { 8136 jtv, ok := value.(string) 8137 if !ok { 8138 return fmt.Errorf("expected DeinterlacerMode to be of type string, got %T instead", value) 8139 } 8140 sv.Mode = types.DeinterlacerMode(jtv) 8141 } 8142 8143 default: 8144 _, _ = key, value 8145 8146 } 8147 } 8148 *v = sv 8149 return nil 8150} 8151 8152func awsRestjson1_deserializeDocumentDestinationSettings(v **types.DestinationSettings, value interface{}) error { 8153 if v == nil { 8154 return fmt.Errorf("unexpected nil of type %T", v) 8155 } 8156 if value == nil { 8157 return nil 8158 } 8159 8160 shape, ok := value.(map[string]interface{}) 8161 if !ok { 8162 return fmt.Errorf("unexpected JSON type %v", value) 8163 } 8164 8165 var sv *types.DestinationSettings 8166 if *v == nil { 8167 sv = &types.DestinationSettings{} 8168 } else { 8169 sv = *v 8170 } 8171 8172 for key, value := range shape { 8173 switch key { 8174 case "s3Settings": 8175 if err := awsRestjson1_deserializeDocumentS3DestinationSettings(&sv.S3Settings, value); err != nil { 8176 return err 8177 } 8178 8179 default: 8180 _, _ = key, value 8181 8182 } 8183 } 8184 *v = sv 8185 return nil 8186} 8187 8188func awsRestjson1_deserializeDocumentDolbyVision(v **types.DolbyVision, value interface{}) error { 8189 if v == nil { 8190 return fmt.Errorf("unexpected nil of type %T", v) 8191 } 8192 if value == nil { 8193 return nil 8194 } 8195 8196 shape, ok := value.(map[string]interface{}) 8197 if !ok { 8198 return fmt.Errorf("unexpected JSON type %v", value) 8199 } 8200 8201 var sv *types.DolbyVision 8202 if *v == nil { 8203 sv = &types.DolbyVision{} 8204 } else { 8205 sv = *v 8206 } 8207 8208 for key, value := range shape { 8209 switch key { 8210 case "l6Metadata": 8211 if err := awsRestjson1_deserializeDocumentDolbyVisionLevel6Metadata(&sv.L6Metadata, value); err != nil { 8212 return err 8213 } 8214 8215 case "l6Mode": 8216 if value != nil { 8217 jtv, ok := value.(string) 8218 if !ok { 8219 return fmt.Errorf("expected DolbyVisionLevel6Mode to be of type string, got %T instead", value) 8220 } 8221 sv.L6Mode = types.DolbyVisionLevel6Mode(jtv) 8222 } 8223 8224 case "profile": 8225 if value != nil { 8226 jtv, ok := value.(string) 8227 if !ok { 8228 return fmt.Errorf("expected DolbyVisionProfile to be of type string, got %T instead", value) 8229 } 8230 sv.Profile = types.DolbyVisionProfile(jtv) 8231 } 8232 8233 default: 8234 _, _ = key, value 8235 8236 } 8237 } 8238 *v = sv 8239 return nil 8240} 8241 8242func awsRestjson1_deserializeDocumentDolbyVisionLevel6Metadata(v **types.DolbyVisionLevel6Metadata, value interface{}) error { 8243 if v == nil { 8244 return fmt.Errorf("unexpected nil of type %T", v) 8245 } 8246 if value == nil { 8247 return nil 8248 } 8249 8250 shape, ok := value.(map[string]interface{}) 8251 if !ok { 8252 return fmt.Errorf("unexpected JSON type %v", value) 8253 } 8254 8255 var sv *types.DolbyVisionLevel6Metadata 8256 if *v == nil { 8257 sv = &types.DolbyVisionLevel6Metadata{} 8258 } else { 8259 sv = *v 8260 } 8261 8262 for key, value := range shape { 8263 switch key { 8264 case "maxCll": 8265 if value != nil { 8266 jtv, ok := value.(json.Number) 8267 if !ok { 8268 return fmt.Errorf("expected __integerMin0Max65535 to be json.Number, got %T instead", value) 8269 } 8270 i64, err := jtv.Int64() 8271 if err != nil { 8272 return err 8273 } 8274 sv.MaxCll = int32(i64) 8275 } 8276 8277 case "maxFall": 8278 if value != nil { 8279 jtv, ok := value.(json.Number) 8280 if !ok { 8281 return fmt.Errorf("expected __integerMin0Max65535 to be json.Number, got %T instead", value) 8282 } 8283 i64, err := jtv.Int64() 8284 if err != nil { 8285 return err 8286 } 8287 sv.MaxFall = int32(i64) 8288 } 8289 8290 default: 8291 _, _ = key, value 8292 8293 } 8294 } 8295 *v = sv 8296 return nil 8297} 8298 8299func awsRestjson1_deserializeDocumentDvbNitSettings(v **types.DvbNitSettings, value interface{}) error { 8300 if v == nil { 8301 return fmt.Errorf("unexpected nil of type %T", v) 8302 } 8303 if value == nil { 8304 return nil 8305 } 8306 8307 shape, ok := value.(map[string]interface{}) 8308 if !ok { 8309 return fmt.Errorf("unexpected JSON type %v", value) 8310 } 8311 8312 var sv *types.DvbNitSettings 8313 if *v == nil { 8314 sv = &types.DvbNitSettings{} 8315 } else { 8316 sv = *v 8317 } 8318 8319 for key, value := range shape { 8320 switch key { 8321 case "networkId": 8322 if value != nil { 8323 jtv, ok := value.(json.Number) 8324 if !ok { 8325 return fmt.Errorf("expected __integerMin0Max65535 to be json.Number, got %T instead", value) 8326 } 8327 i64, err := jtv.Int64() 8328 if err != nil { 8329 return err 8330 } 8331 sv.NetworkId = int32(i64) 8332 } 8333 8334 case "networkName": 8335 if value != nil { 8336 jtv, ok := value.(string) 8337 if !ok { 8338 return fmt.Errorf("expected __stringMin1Max256 to be of type string, got %T instead", value) 8339 } 8340 sv.NetworkName = ptr.String(jtv) 8341 } 8342 8343 case "nitInterval": 8344 if value != nil { 8345 jtv, ok := value.(json.Number) 8346 if !ok { 8347 return fmt.Errorf("expected __integerMin25Max10000 to be json.Number, got %T instead", value) 8348 } 8349 i64, err := jtv.Int64() 8350 if err != nil { 8351 return err 8352 } 8353 sv.NitInterval = int32(i64) 8354 } 8355 8356 default: 8357 _, _ = key, value 8358 8359 } 8360 } 8361 *v = sv 8362 return nil 8363} 8364 8365func awsRestjson1_deserializeDocumentDvbSdtSettings(v **types.DvbSdtSettings, value interface{}) error { 8366 if v == nil { 8367 return fmt.Errorf("unexpected nil of type %T", v) 8368 } 8369 if value == nil { 8370 return nil 8371 } 8372 8373 shape, ok := value.(map[string]interface{}) 8374 if !ok { 8375 return fmt.Errorf("unexpected JSON type %v", value) 8376 } 8377 8378 var sv *types.DvbSdtSettings 8379 if *v == nil { 8380 sv = &types.DvbSdtSettings{} 8381 } else { 8382 sv = *v 8383 } 8384 8385 for key, value := range shape { 8386 switch key { 8387 case "outputSdt": 8388 if value != nil { 8389 jtv, ok := value.(string) 8390 if !ok { 8391 return fmt.Errorf("expected OutputSdt to be of type string, got %T instead", value) 8392 } 8393 sv.OutputSdt = types.OutputSdt(jtv) 8394 } 8395 8396 case "sdtInterval": 8397 if value != nil { 8398 jtv, ok := value.(json.Number) 8399 if !ok { 8400 return fmt.Errorf("expected __integerMin25Max2000 to be json.Number, got %T instead", value) 8401 } 8402 i64, err := jtv.Int64() 8403 if err != nil { 8404 return err 8405 } 8406 sv.SdtInterval = int32(i64) 8407 } 8408 8409 case "serviceName": 8410 if value != nil { 8411 jtv, ok := value.(string) 8412 if !ok { 8413 return fmt.Errorf("expected __stringMin1Max256 to be of type string, got %T instead", value) 8414 } 8415 sv.ServiceName = ptr.String(jtv) 8416 } 8417 8418 case "serviceProviderName": 8419 if value != nil { 8420 jtv, ok := value.(string) 8421 if !ok { 8422 return fmt.Errorf("expected __stringMin1Max256 to be of type string, got %T instead", value) 8423 } 8424 sv.ServiceProviderName = ptr.String(jtv) 8425 } 8426 8427 default: 8428 _, _ = key, value 8429 8430 } 8431 } 8432 *v = sv 8433 return nil 8434} 8435 8436func awsRestjson1_deserializeDocumentDvbSubDestinationSettings(v **types.DvbSubDestinationSettings, value interface{}) error { 8437 if v == nil { 8438 return fmt.Errorf("unexpected nil of type %T", v) 8439 } 8440 if value == nil { 8441 return nil 8442 } 8443 8444 shape, ok := value.(map[string]interface{}) 8445 if !ok { 8446 return fmt.Errorf("unexpected JSON type %v", value) 8447 } 8448 8449 var sv *types.DvbSubDestinationSettings 8450 if *v == nil { 8451 sv = &types.DvbSubDestinationSettings{} 8452 } else { 8453 sv = *v 8454 } 8455 8456 for key, value := range shape { 8457 switch key { 8458 case "alignment": 8459 if value != nil { 8460 jtv, ok := value.(string) 8461 if !ok { 8462 return fmt.Errorf("expected DvbSubtitleAlignment to be of type string, got %T instead", value) 8463 } 8464 sv.Alignment = types.DvbSubtitleAlignment(jtv) 8465 } 8466 8467 case "backgroundColor": 8468 if value != nil { 8469 jtv, ok := value.(string) 8470 if !ok { 8471 return fmt.Errorf("expected DvbSubtitleBackgroundColor to be of type string, got %T instead", value) 8472 } 8473 sv.BackgroundColor = types.DvbSubtitleBackgroundColor(jtv) 8474 } 8475 8476 case "backgroundOpacity": 8477 if value != nil { 8478 jtv, ok := value.(json.Number) 8479 if !ok { 8480 return fmt.Errorf("expected __integerMin0Max255 to be json.Number, got %T instead", value) 8481 } 8482 i64, err := jtv.Int64() 8483 if err != nil { 8484 return err 8485 } 8486 sv.BackgroundOpacity = int32(i64) 8487 } 8488 8489 case "fontColor": 8490 if value != nil { 8491 jtv, ok := value.(string) 8492 if !ok { 8493 return fmt.Errorf("expected DvbSubtitleFontColor to be of type string, got %T instead", value) 8494 } 8495 sv.FontColor = types.DvbSubtitleFontColor(jtv) 8496 } 8497 8498 case "fontOpacity": 8499 if value != nil { 8500 jtv, ok := value.(json.Number) 8501 if !ok { 8502 return fmt.Errorf("expected __integerMin0Max255 to be json.Number, got %T instead", value) 8503 } 8504 i64, err := jtv.Int64() 8505 if err != nil { 8506 return err 8507 } 8508 sv.FontOpacity = int32(i64) 8509 } 8510 8511 case "fontResolution": 8512 if value != nil { 8513 jtv, ok := value.(json.Number) 8514 if !ok { 8515 return fmt.Errorf("expected __integerMin96Max600 to be json.Number, got %T instead", value) 8516 } 8517 i64, err := jtv.Int64() 8518 if err != nil { 8519 return err 8520 } 8521 sv.FontResolution = int32(i64) 8522 } 8523 8524 case "fontScript": 8525 if value != nil { 8526 jtv, ok := value.(string) 8527 if !ok { 8528 return fmt.Errorf("expected FontScript to be of type string, got %T instead", value) 8529 } 8530 sv.FontScript = types.FontScript(jtv) 8531 } 8532 8533 case "fontSize": 8534 if value != nil { 8535 jtv, ok := value.(json.Number) 8536 if !ok { 8537 return fmt.Errorf("expected __integerMin0Max96 to be json.Number, got %T instead", value) 8538 } 8539 i64, err := jtv.Int64() 8540 if err != nil { 8541 return err 8542 } 8543 sv.FontSize = int32(i64) 8544 } 8545 8546 case "outlineColor": 8547 if value != nil { 8548 jtv, ok := value.(string) 8549 if !ok { 8550 return fmt.Errorf("expected DvbSubtitleOutlineColor to be of type string, got %T instead", value) 8551 } 8552 sv.OutlineColor = types.DvbSubtitleOutlineColor(jtv) 8553 } 8554 8555 case "outlineSize": 8556 if value != nil { 8557 jtv, ok := value.(json.Number) 8558 if !ok { 8559 return fmt.Errorf("expected __integerMin0Max10 to be json.Number, got %T instead", value) 8560 } 8561 i64, err := jtv.Int64() 8562 if err != nil { 8563 return err 8564 } 8565 sv.OutlineSize = int32(i64) 8566 } 8567 8568 case "shadowColor": 8569 if value != nil { 8570 jtv, ok := value.(string) 8571 if !ok { 8572 return fmt.Errorf("expected DvbSubtitleShadowColor to be of type string, got %T instead", value) 8573 } 8574 sv.ShadowColor = types.DvbSubtitleShadowColor(jtv) 8575 } 8576 8577 case "shadowOpacity": 8578 if value != nil { 8579 jtv, ok := value.(json.Number) 8580 if !ok { 8581 return fmt.Errorf("expected __integerMin0Max255 to be json.Number, got %T instead", value) 8582 } 8583 i64, err := jtv.Int64() 8584 if err != nil { 8585 return err 8586 } 8587 sv.ShadowOpacity = int32(i64) 8588 } 8589 8590 case "shadowXOffset": 8591 if value != nil { 8592 jtv, ok := value.(json.Number) 8593 if !ok { 8594 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 8595 } 8596 i64, err := jtv.Int64() 8597 if err != nil { 8598 return err 8599 } 8600 sv.ShadowXOffset = int32(i64) 8601 } 8602 8603 case "shadowYOffset": 8604 if value != nil { 8605 jtv, ok := value.(json.Number) 8606 if !ok { 8607 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 8608 } 8609 i64, err := jtv.Int64() 8610 if err != nil { 8611 return err 8612 } 8613 sv.ShadowYOffset = int32(i64) 8614 } 8615 8616 case "subtitlingType": 8617 if value != nil { 8618 jtv, ok := value.(string) 8619 if !ok { 8620 return fmt.Errorf("expected DvbSubtitlingType to be of type string, got %T instead", value) 8621 } 8622 sv.SubtitlingType = types.DvbSubtitlingType(jtv) 8623 } 8624 8625 case "teletextSpacing": 8626 if value != nil { 8627 jtv, ok := value.(string) 8628 if !ok { 8629 return fmt.Errorf("expected DvbSubtitleTeletextSpacing to be of type string, got %T instead", value) 8630 } 8631 sv.TeletextSpacing = types.DvbSubtitleTeletextSpacing(jtv) 8632 } 8633 8634 case "xPosition": 8635 if value != nil { 8636 jtv, ok := value.(json.Number) 8637 if !ok { 8638 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 8639 } 8640 i64, err := jtv.Int64() 8641 if err != nil { 8642 return err 8643 } 8644 sv.XPosition = int32(i64) 8645 } 8646 8647 case "yPosition": 8648 if value != nil { 8649 jtv, ok := value.(json.Number) 8650 if !ok { 8651 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 8652 } 8653 i64, err := jtv.Int64() 8654 if err != nil { 8655 return err 8656 } 8657 sv.YPosition = int32(i64) 8658 } 8659 8660 default: 8661 _, _ = key, value 8662 8663 } 8664 } 8665 *v = sv 8666 return nil 8667} 8668 8669func awsRestjson1_deserializeDocumentDvbSubSourceSettings(v **types.DvbSubSourceSettings, value interface{}) error { 8670 if v == nil { 8671 return fmt.Errorf("unexpected nil of type %T", v) 8672 } 8673 if value == nil { 8674 return nil 8675 } 8676 8677 shape, ok := value.(map[string]interface{}) 8678 if !ok { 8679 return fmt.Errorf("unexpected JSON type %v", value) 8680 } 8681 8682 var sv *types.DvbSubSourceSettings 8683 if *v == nil { 8684 sv = &types.DvbSubSourceSettings{} 8685 } else { 8686 sv = *v 8687 } 8688 8689 for key, value := range shape { 8690 switch key { 8691 case "pid": 8692 if value != nil { 8693 jtv, ok := value.(json.Number) 8694 if !ok { 8695 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 8696 } 8697 i64, err := jtv.Int64() 8698 if err != nil { 8699 return err 8700 } 8701 sv.Pid = int32(i64) 8702 } 8703 8704 default: 8705 _, _ = key, value 8706 8707 } 8708 } 8709 *v = sv 8710 return nil 8711} 8712 8713func awsRestjson1_deserializeDocumentDvbTdtSettings(v **types.DvbTdtSettings, value interface{}) error { 8714 if v == nil { 8715 return fmt.Errorf("unexpected nil of type %T", v) 8716 } 8717 if value == nil { 8718 return nil 8719 } 8720 8721 shape, ok := value.(map[string]interface{}) 8722 if !ok { 8723 return fmt.Errorf("unexpected JSON type %v", value) 8724 } 8725 8726 var sv *types.DvbTdtSettings 8727 if *v == nil { 8728 sv = &types.DvbTdtSettings{} 8729 } else { 8730 sv = *v 8731 } 8732 8733 for key, value := range shape { 8734 switch key { 8735 case "tdtInterval": 8736 if value != nil { 8737 jtv, ok := value.(json.Number) 8738 if !ok { 8739 return fmt.Errorf("expected __integerMin1000Max30000 to be json.Number, got %T instead", value) 8740 } 8741 i64, err := jtv.Int64() 8742 if err != nil { 8743 return err 8744 } 8745 sv.TdtInterval = int32(i64) 8746 } 8747 8748 default: 8749 _, _ = key, value 8750 8751 } 8752 } 8753 *v = sv 8754 return nil 8755} 8756 8757func awsRestjson1_deserializeDocumentEac3AtmosSettings(v **types.Eac3AtmosSettings, value interface{}) error { 8758 if v == nil { 8759 return fmt.Errorf("unexpected nil of type %T", v) 8760 } 8761 if value == nil { 8762 return nil 8763 } 8764 8765 shape, ok := value.(map[string]interface{}) 8766 if !ok { 8767 return fmt.Errorf("unexpected JSON type %v", value) 8768 } 8769 8770 var sv *types.Eac3AtmosSettings 8771 if *v == nil { 8772 sv = &types.Eac3AtmosSettings{} 8773 } else { 8774 sv = *v 8775 } 8776 8777 for key, value := range shape { 8778 switch key { 8779 case "bitrate": 8780 if value != nil { 8781 jtv, ok := value.(json.Number) 8782 if !ok { 8783 return fmt.Errorf("expected __integerMin384000Max768000 to be json.Number, got %T instead", value) 8784 } 8785 i64, err := jtv.Int64() 8786 if err != nil { 8787 return err 8788 } 8789 sv.Bitrate = int32(i64) 8790 } 8791 8792 case "bitstreamMode": 8793 if value != nil { 8794 jtv, ok := value.(string) 8795 if !ok { 8796 return fmt.Errorf("expected Eac3AtmosBitstreamMode to be of type string, got %T instead", value) 8797 } 8798 sv.BitstreamMode = types.Eac3AtmosBitstreamMode(jtv) 8799 } 8800 8801 case "codingMode": 8802 if value != nil { 8803 jtv, ok := value.(string) 8804 if !ok { 8805 return fmt.Errorf("expected Eac3AtmosCodingMode to be of type string, got %T instead", value) 8806 } 8807 sv.CodingMode = types.Eac3AtmosCodingMode(jtv) 8808 } 8809 8810 case "dialogueIntelligence": 8811 if value != nil { 8812 jtv, ok := value.(string) 8813 if !ok { 8814 return fmt.Errorf("expected Eac3AtmosDialogueIntelligence to be of type string, got %T instead", value) 8815 } 8816 sv.DialogueIntelligence = types.Eac3AtmosDialogueIntelligence(jtv) 8817 } 8818 8819 case "dynamicRangeCompressionLine": 8820 if value != nil { 8821 jtv, ok := value.(string) 8822 if !ok { 8823 return fmt.Errorf("expected Eac3AtmosDynamicRangeCompressionLine to be of type string, got %T instead", value) 8824 } 8825 sv.DynamicRangeCompressionLine = types.Eac3AtmosDynamicRangeCompressionLine(jtv) 8826 } 8827 8828 case "dynamicRangeCompressionRf": 8829 if value != nil { 8830 jtv, ok := value.(string) 8831 if !ok { 8832 return fmt.Errorf("expected Eac3AtmosDynamicRangeCompressionRf to be of type string, got %T instead", value) 8833 } 8834 sv.DynamicRangeCompressionRf = types.Eac3AtmosDynamicRangeCompressionRf(jtv) 8835 } 8836 8837 case "loRoCenterMixLevel": 8838 if value != nil { 8839 jtv, ok := value.(json.Number) 8840 if !ok { 8841 return fmt.Errorf("expected __doubleMinNegative6Max3 to be json.Number, got %T instead", value) 8842 } 8843 f64, err := jtv.Float64() 8844 if err != nil { 8845 return err 8846 } 8847 sv.LoRoCenterMixLevel = f64 8848 } 8849 8850 case "loRoSurroundMixLevel": 8851 if value != nil { 8852 jtv, ok := value.(json.Number) 8853 if !ok { 8854 return fmt.Errorf("expected __doubleMinNegative60MaxNegative1 to be json.Number, got %T instead", value) 8855 } 8856 f64, err := jtv.Float64() 8857 if err != nil { 8858 return err 8859 } 8860 sv.LoRoSurroundMixLevel = f64 8861 } 8862 8863 case "ltRtCenterMixLevel": 8864 if value != nil { 8865 jtv, ok := value.(json.Number) 8866 if !ok { 8867 return fmt.Errorf("expected __doubleMinNegative6Max3 to be json.Number, got %T instead", value) 8868 } 8869 f64, err := jtv.Float64() 8870 if err != nil { 8871 return err 8872 } 8873 sv.LtRtCenterMixLevel = f64 8874 } 8875 8876 case "ltRtSurroundMixLevel": 8877 if value != nil { 8878 jtv, ok := value.(json.Number) 8879 if !ok { 8880 return fmt.Errorf("expected __doubleMinNegative60MaxNegative1 to be json.Number, got %T instead", value) 8881 } 8882 f64, err := jtv.Float64() 8883 if err != nil { 8884 return err 8885 } 8886 sv.LtRtSurroundMixLevel = f64 8887 } 8888 8889 case "meteringMode": 8890 if value != nil { 8891 jtv, ok := value.(string) 8892 if !ok { 8893 return fmt.Errorf("expected Eac3AtmosMeteringMode to be of type string, got %T instead", value) 8894 } 8895 sv.MeteringMode = types.Eac3AtmosMeteringMode(jtv) 8896 } 8897 8898 case "sampleRate": 8899 if value != nil { 8900 jtv, ok := value.(json.Number) 8901 if !ok { 8902 return fmt.Errorf("expected __integerMin48000Max48000 to be json.Number, got %T instead", value) 8903 } 8904 i64, err := jtv.Int64() 8905 if err != nil { 8906 return err 8907 } 8908 sv.SampleRate = int32(i64) 8909 } 8910 8911 case "speechThreshold": 8912 if value != nil { 8913 jtv, ok := value.(json.Number) 8914 if !ok { 8915 return fmt.Errorf("expected __integerMin1Max100 to be json.Number, got %T instead", value) 8916 } 8917 i64, err := jtv.Int64() 8918 if err != nil { 8919 return err 8920 } 8921 sv.SpeechThreshold = int32(i64) 8922 } 8923 8924 case "stereoDownmix": 8925 if value != nil { 8926 jtv, ok := value.(string) 8927 if !ok { 8928 return fmt.Errorf("expected Eac3AtmosStereoDownmix to be of type string, got %T instead", value) 8929 } 8930 sv.StereoDownmix = types.Eac3AtmosStereoDownmix(jtv) 8931 } 8932 8933 case "surroundExMode": 8934 if value != nil { 8935 jtv, ok := value.(string) 8936 if !ok { 8937 return fmt.Errorf("expected Eac3AtmosSurroundExMode to be of type string, got %T instead", value) 8938 } 8939 sv.SurroundExMode = types.Eac3AtmosSurroundExMode(jtv) 8940 } 8941 8942 default: 8943 _, _ = key, value 8944 8945 } 8946 } 8947 *v = sv 8948 return nil 8949} 8950 8951func awsRestjson1_deserializeDocumentEac3Settings(v **types.Eac3Settings, value interface{}) error { 8952 if v == nil { 8953 return fmt.Errorf("unexpected nil of type %T", v) 8954 } 8955 if value == nil { 8956 return nil 8957 } 8958 8959 shape, ok := value.(map[string]interface{}) 8960 if !ok { 8961 return fmt.Errorf("unexpected JSON type %v", value) 8962 } 8963 8964 var sv *types.Eac3Settings 8965 if *v == nil { 8966 sv = &types.Eac3Settings{} 8967 } else { 8968 sv = *v 8969 } 8970 8971 for key, value := range shape { 8972 switch key { 8973 case "attenuationControl": 8974 if value != nil { 8975 jtv, ok := value.(string) 8976 if !ok { 8977 return fmt.Errorf("expected Eac3AttenuationControl to be of type string, got %T instead", value) 8978 } 8979 sv.AttenuationControl = types.Eac3AttenuationControl(jtv) 8980 } 8981 8982 case "bitrate": 8983 if value != nil { 8984 jtv, ok := value.(json.Number) 8985 if !ok { 8986 return fmt.Errorf("expected __integerMin64000Max640000 to be json.Number, got %T instead", value) 8987 } 8988 i64, err := jtv.Int64() 8989 if err != nil { 8990 return err 8991 } 8992 sv.Bitrate = int32(i64) 8993 } 8994 8995 case "bitstreamMode": 8996 if value != nil { 8997 jtv, ok := value.(string) 8998 if !ok { 8999 return fmt.Errorf("expected Eac3BitstreamMode to be of type string, got %T instead", value) 9000 } 9001 sv.BitstreamMode = types.Eac3BitstreamMode(jtv) 9002 } 9003 9004 case "codingMode": 9005 if value != nil { 9006 jtv, ok := value.(string) 9007 if !ok { 9008 return fmt.Errorf("expected Eac3CodingMode to be of type string, got %T instead", value) 9009 } 9010 sv.CodingMode = types.Eac3CodingMode(jtv) 9011 } 9012 9013 case "dcFilter": 9014 if value != nil { 9015 jtv, ok := value.(string) 9016 if !ok { 9017 return fmt.Errorf("expected Eac3DcFilter to be of type string, got %T instead", value) 9018 } 9019 sv.DcFilter = types.Eac3DcFilter(jtv) 9020 } 9021 9022 case "dialnorm": 9023 if value != nil { 9024 jtv, ok := value.(json.Number) 9025 if !ok { 9026 return fmt.Errorf("expected __integerMin1Max31 to be json.Number, got %T instead", value) 9027 } 9028 i64, err := jtv.Int64() 9029 if err != nil { 9030 return err 9031 } 9032 sv.Dialnorm = int32(i64) 9033 } 9034 9035 case "dynamicRangeCompressionLine": 9036 if value != nil { 9037 jtv, ok := value.(string) 9038 if !ok { 9039 return fmt.Errorf("expected Eac3DynamicRangeCompressionLine to be of type string, got %T instead", value) 9040 } 9041 sv.DynamicRangeCompressionLine = types.Eac3DynamicRangeCompressionLine(jtv) 9042 } 9043 9044 case "dynamicRangeCompressionRf": 9045 if value != nil { 9046 jtv, ok := value.(string) 9047 if !ok { 9048 return fmt.Errorf("expected Eac3DynamicRangeCompressionRf to be of type string, got %T instead", value) 9049 } 9050 sv.DynamicRangeCompressionRf = types.Eac3DynamicRangeCompressionRf(jtv) 9051 } 9052 9053 case "lfeControl": 9054 if value != nil { 9055 jtv, ok := value.(string) 9056 if !ok { 9057 return fmt.Errorf("expected Eac3LfeControl to be of type string, got %T instead", value) 9058 } 9059 sv.LfeControl = types.Eac3LfeControl(jtv) 9060 } 9061 9062 case "lfeFilter": 9063 if value != nil { 9064 jtv, ok := value.(string) 9065 if !ok { 9066 return fmt.Errorf("expected Eac3LfeFilter to be of type string, got %T instead", value) 9067 } 9068 sv.LfeFilter = types.Eac3LfeFilter(jtv) 9069 } 9070 9071 case "loRoCenterMixLevel": 9072 if value != nil { 9073 jtv, ok := value.(json.Number) 9074 if !ok { 9075 return fmt.Errorf("expected __doubleMinNegative60Max3 to be json.Number, got %T instead", value) 9076 } 9077 f64, err := jtv.Float64() 9078 if err != nil { 9079 return err 9080 } 9081 sv.LoRoCenterMixLevel = f64 9082 } 9083 9084 case "loRoSurroundMixLevel": 9085 if value != nil { 9086 jtv, ok := value.(json.Number) 9087 if !ok { 9088 return fmt.Errorf("expected __doubleMinNegative60MaxNegative1 to be json.Number, got %T instead", value) 9089 } 9090 f64, err := jtv.Float64() 9091 if err != nil { 9092 return err 9093 } 9094 sv.LoRoSurroundMixLevel = f64 9095 } 9096 9097 case "ltRtCenterMixLevel": 9098 if value != nil { 9099 jtv, ok := value.(json.Number) 9100 if !ok { 9101 return fmt.Errorf("expected __doubleMinNegative60Max3 to be json.Number, got %T instead", value) 9102 } 9103 f64, err := jtv.Float64() 9104 if err != nil { 9105 return err 9106 } 9107 sv.LtRtCenterMixLevel = f64 9108 } 9109 9110 case "ltRtSurroundMixLevel": 9111 if value != nil { 9112 jtv, ok := value.(json.Number) 9113 if !ok { 9114 return fmt.Errorf("expected __doubleMinNegative60MaxNegative1 to be json.Number, got %T instead", value) 9115 } 9116 f64, err := jtv.Float64() 9117 if err != nil { 9118 return err 9119 } 9120 sv.LtRtSurroundMixLevel = f64 9121 } 9122 9123 case "metadataControl": 9124 if value != nil { 9125 jtv, ok := value.(string) 9126 if !ok { 9127 return fmt.Errorf("expected Eac3MetadataControl to be of type string, got %T instead", value) 9128 } 9129 sv.MetadataControl = types.Eac3MetadataControl(jtv) 9130 } 9131 9132 case "passthroughControl": 9133 if value != nil { 9134 jtv, ok := value.(string) 9135 if !ok { 9136 return fmt.Errorf("expected Eac3PassthroughControl to be of type string, got %T instead", value) 9137 } 9138 sv.PassthroughControl = types.Eac3PassthroughControl(jtv) 9139 } 9140 9141 case "phaseControl": 9142 if value != nil { 9143 jtv, ok := value.(string) 9144 if !ok { 9145 return fmt.Errorf("expected Eac3PhaseControl to be of type string, got %T instead", value) 9146 } 9147 sv.PhaseControl = types.Eac3PhaseControl(jtv) 9148 } 9149 9150 case "sampleRate": 9151 if value != nil { 9152 jtv, ok := value.(json.Number) 9153 if !ok { 9154 return fmt.Errorf("expected __integerMin48000Max48000 to be json.Number, got %T instead", value) 9155 } 9156 i64, err := jtv.Int64() 9157 if err != nil { 9158 return err 9159 } 9160 sv.SampleRate = int32(i64) 9161 } 9162 9163 case "stereoDownmix": 9164 if value != nil { 9165 jtv, ok := value.(string) 9166 if !ok { 9167 return fmt.Errorf("expected Eac3StereoDownmix to be of type string, got %T instead", value) 9168 } 9169 sv.StereoDownmix = types.Eac3StereoDownmix(jtv) 9170 } 9171 9172 case "surroundExMode": 9173 if value != nil { 9174 jtv, ok := value.(string) 9175 if !ok { 9176 return fmt.Errorf("expected Eac3SurroundExMode to be of type string, got %T instead", value) 9177 } 9178 sv.SurroundExMode = types.Eac3SurroundExMode(jtv) 9179 } 9180 9181 case "surroundMode": 9182 if value != nil { 9183 jtv, ok := value.(string) 9184 if !ok { 9185 return fmt.Errorf("expected Eac3SurroundMode to be of type string, got %T instead", value) 9186 } 9187 sv.SurroundMode = types.Eac3SurroundMode(jtv) 9188 } 9189 9190 default: 9191 _, _ = key, value 9192 9193 } 9194 } 9195 *v = sv 9196 return nil 9197} 9198 9199func awsRestjson1_deserializeDocumentEmbeddedDestinationSettings(v **types.EmbeddedDestinationSettings, value interface{}) error { 9200 if v == nil { 9201 return fmt.Errorf("unexpected nil of type %T", v) 9202 } 9203 if value == nil { 9204 return nil 9205 } 9206 9207 shape, ok := value.(map[string]interface{}) 9208 if !ok { 9209 return fmt.Errorf("unexpected JSON type %v", value) 9210 } 9211 9212 var sv *types.EmbeddedDestinationSettings 9213 if *v == nil { 9214 sv = &types.EmbeddedDestinationSettings{} 9215 } else { 9216 sv = *v 9217 } 9218 9219 for key, value := range shape { 9220 switch key { 9221 case "destination608ChannelNumber": 9222 if value != nil { 9223 jtv, ok := value.(json.Number) 9224 if !ok { 9225 return fmt.Errorf("expected __integerMin1Max4 to be json.Number, got %T instead", value) 9226 } 9227 i64, err := jtv.Int64() 9228 if err != nil { 9229 return err 9230 } 9231 sv.Destination608ChannelNumber = int32(i64) 9232 } 9233 9234 case "destination708ServiceNumber": 9235 if value != nil { 9236 jtv, ok := value.(json.Number) 9237 if !ok { 9238 return fmt.Errorf("expected __integerMin1Max6 to be json.Number, got %T instead", value) 9239 } 9240 i64, err := jtv.Int64() 9241 if err != nil { 9242 return err 9243 } 9244 sv.Destination708ServiceNumber = int32(i64) 9245 } 9246 9247 default: 9248 _, _ = key, value 9249 9250 } 9251 } 9252 *v = sv 9253 return nil 9254} 9255 9256func awsRestjson1_deserializeDocumentEmbeddedSourceSettings(v **types.EmbeddedSourceSettings, value interface{}) error { 9257 if v == nil { 9258 return fmt.Errorf("unexpected nil of type %T", v) 9259 } 9260 if value == nil { 9261 return nil 9262 } 9263 9264 shape, ok := value.(map[string]interface{}) 9265 if !ok { 9266 return fmt.Errorf("unexpected JSON type %v", value) 9267 } 9268 9269 var sv *types.EmbeddedSourceSettings 9270 if *v == nil { 9271 sv = &types.EmbeddedSourceSettings{} 9272 } else { 9273 sv = *v 9274 } 9275 9276 for key, value := range shape { 9277 switch key { 9278 case "convert608To708": 9279 if value != nil { 9280 jtv, ok := value.(string) 9281 if !ok { 9282 return fmt.Errorf("expected EmbeddedConvert608To708 to be of type string, got %T instead", value) 9283 } 9284 sv.Convert608To708 = types.EmbeddedConvert608To708(jtv) 9285 } 9286 9287 case "source608ChannelNumber": 9288 if value != nil { 9289 jtv, ok := value.(json.Number) 9290 if !ok { 9291 return fmt.Errorf("expected __integerMin1Max4 to be json.Number, got %T instead", value) 9292 } 9293 i64, err := jtv.Int64() 9294 if err != nil { 9295 return err 9296 } 9297 sv.Source608ChannelNumber = int32(i64) 9298 } 9299 9300 case "source608TrackNumber": 9301 if value != nil { 9302 jtv, ok := value.(json.Number) 9303 if !ok { 9304 return fmt.Errorf("expected __integerMin1Max1 to be json.Number, got %T instead", value) 9305 } 9306 i64, err := jtv.Int64() 9307 if err != nil { 9308 return err 9309 } 9310 sv.Source608TrackNumber = int32(i64) 9311 } 9312 9313 case "terminateCaptions": 9314 if value != nil { 9315 jtv, ok := value.(string) 9316 if !ok { 9317 return fmt.Errorf("expected EmbeddedTerminateCaptions to be of type string, got %T instead", value) 9318 } 9319 sv.TerminateCaptions = types.EmbeddedTerminateCaptions(jtv) 9320 } 9321 9322 default: 9323 _, _ = key, value 9324 9325 } 9326 } 9327 *v = sv 9328 return nil 9329} 9330 9331func awsRestjson1_deserializeDocumentEndpoint(v **types.Endpoint, value interface{}) error { 9332 if v == nil { 9333 return fmt.Errorf("unexpected nil of type %T", v) 9334 } 9335 if value == nil { 9336 return nil 9337 } 9338 9339 shape, ok := value.(map[string]interface{}) 9340 if !ok { 9341 return fmt.Errorf("unexpected JSON type %v", value) 9342 } 9343 9344 var sv *types.Endpoint 9345 if *v == nil { 9346 sv = &types.Endpoint{} 9347 } else { 9348 sv = *v 9349 } 9350 9351 for key, value := range shape { 9352 switch key { 9353 case "url": 9354 if value != nil { 9355 jtv, ok := value.(string) 9356 if !ok { 9357 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9358 } 9359 sv.Url = ptr.String(jtv) 9360 } 9361 9362 default: 9363 _, _ = key, value 9364 9365 } 9366 } 9367 *v = sv 9368 return nil 9369} 9370 9371func awsRestjson1_deserializeDocumentEsamManifestConfirmConditionNotification(v **types.EsamManifestConfirmConditionNotification, value interface{}) error { 9372 if v == nil { 9373 return fmt.Errorf("unexpected nil of type %T", v) 9374 } 9375 if value == nil { 9376 return nil 9377 } 9378 9379 shape, ok := value.(map[string]interface{}) 9380 if !ok { 9381 return fmt.Errorf("unexpected JSON type %v", value) 9382 } 9383 9384 var sv *types.EsamManifestConfirmConditionNotification 9385 if *v == nil { 9386 sv = &types.EsamManifestConfirmConditionNotification{} 9387 } else { 9388 sv = *v 9389 } 9390 9391 for key, value := range shape { 9392 switch key { 9393 case "mccXml": 9394 if value != nil { 9395 jtv, ok := value.(string) 9396 if !ok { 9397 return fmt.Errorf("expected __stringPatternSNManifestConfirmConditionNotificationNS to be of type string, got %T instead", value) 9398 } 9399 sv.MccXml = ptr.String(jtv) 9400 } 9401 9402 default: 9403 _, _ = key, value 9404 9405 } 9406 } 9407 *v = sv 9408 return nil 9409} 9410 9411func awsRestjson1_deserializeDocumentEsamSettings(v **types.EsamSettings, value interface{}) error { 9412 if v == nil { 9413 return fmt.Errorf("unexpected nil of type %T", v) 9414 } 9415 if value == nil { 9416 return nil 9417 } 9418 9419 shape, ok := value.(map[string]interface{}) 9420 if !ok { 9421 return fmt.Errorf("unexpected JSON type %v", value) 9422 } 9423 9424 var sv *types.EsamSettings 9425 if *v == nil { 9426 sv = &types.EsamSettings{} 9427 } else { 9428 sv = *v 9429 } 9430 9431 for key, value := range shape { 9432 switch key { 9433 case "manifestConfirmConditionNotification": 9434 if err := awsRestjson1_deserializeDocumentEsamManifestConfirmConditionNotification(&sv.ManifestConfirmConditionNotification, value); err != nil { 9435 return err 9436 } 9437 9438 case "responseSignalPreroll": 9439 if value != nil { 9440 jtv, ok := value.(json.Number) 9441 if !ok { 9442 return fmt.Errorf("expected __integerMin0Max30000 to be json.Number, got %T instead", value) 9443 } 9444 i64, err := jtv.Int64() 9445 if err != nil { 9446 return err 9447 } 9448 sv.ResponseSignalPreroll = int32(i64) 9449 } 9450 9451 case "signalProcessingNotification": 9452 if err := awsRestjson1_deserializeDocumentEsamSignalProcessingNotification(&sv.SignalProcessingNotification, value); err != nil { 9453 return err 9454 } 9455 9456 default: 9457 _, _ = key, value 9458 9459 } 9460 } 9461 *v = sv 9462 return nil 9463} 9464 9465func awsRestjson1_deserializeDocumentEsamSignalProcessingNotification(v **types.EsamSignalProcessingNotification, value interface{}) error { 9466 if v == nil { 9467 return fmt.Errorf("unexpected nil of type %T", v) 9468 } 9469 if value == nil { 9470 return nil 9471 } 9472 9473 shape, ok := value.(map[string]interface{}) 9474 if !ok { 9475 return fmt.Errorf("unexpected JSON type %v", value) 9476 } 9477 9478 var sv *types.EsamSignalProcessingNotification 9479 if *v == nil { 9480 sv = &types.EsamSignalProcessingNotification{} 9481 } else { 9482 sv = *v 9483 } 9484 9485 for key, value := range shape { 9486 switch key { 9487 case "sccXml": 9488 if value != nil { 9489 jtv, ok := value.(string) 9490 if !ok { 9491 return fmt.Errorf("expected __stringPatternSNSignalProcessingNotificationNS to be of type string, got %T instead", value) 9492 } 9493 sv.SccXml = ptr.String(jtv) 9494 } 9495 9496 default: 9497 _, _ = key, value 9498 9499 } 9500 } 9501 *v = sv 9502 return nil 9503} 9504 9505func awsRestjson1_deserializeDocumentF4vSettings(v **types.F4vSettings, value interface{}) error { 9506 if v == nil { 9507 return fmt.Errorf("unexpected nil of type %T", v) 9508 } 9509 if value == nil { 9510 return nil 9511 } 9512 9513 shape, ok := value.(map[string]interface{}) 9514 if !ok { 9515 return fmt.Errorf("unexpected JSON type %v", value) 9516 } 9517 9518 var sv *types.F4vSettings 9519 if *v == nil { 9520 sv = &types.F4vSettings{} 9521 } else { 9522 sv = *v 9523 } 9524 9525 for key, value := range shape { 9526 switch key { 9527 case "moovPlacement": 9528 if value != nil { 9529 jtv, ok := value.(string) 9530 if !ok { 9531 return fmt.Errorf("expected F4vMoovPlacement to be of type string, got %T instead", value) 9532 } 9533 sv.MoovPlacement = types.F4vMoovPlacement(jtv) 9534 } 9535 9536 default: 9537 _, _ = key, value 9538 9539 } 9540 } 9541 *v = sv 9542 return nil 9543} 9544 9545func awsRestjson1_deserializeDocumentFileGroupSettings(v **types.FileGroupSettings, value interface{}) error { 9546 if v == nil { 9547 return fmt.Errorf("unexpected nil of type %T", v) 9548 } 9549 if value == nil { 9550 return nil 9551 } 9552 9553 shape, ok := value.(map[string]interface{}) 9554 if !ok { 9555 return fmt.Errorf("unexpected JSON type %v", value) 9556 } 9557 9558 var sv *types.FileGroupSettings 9559 if *v == nil { 9560 sv = &types.FileGroupSettings{} 9561 } else { 9562 sv = *v 9563 } 9564 9565 for key, value := range shape { 9566 switch key { 9567 case "destination": 9568 if value != nil { 9569 jtv, ok := value.(string) 9570 if !ok { 9571 return fmt.Errorf("expected __stringPatternS3 to be of type string, got %T instead", value) 9572 } 9573 sv.Destination = ptr.String(jtv) 9574 } 9575 9576 case "destinationSettings": 9577 if err := awsRestjson1_deserializeDocumentDestinationSettings(&sv.DestinationSettings, value); err != nil { 9578 return err 9579 } 9580 9581 default: 9582 _, _ = key, value 9583 9584 } 9585 } 9586 *v = sv 9587 return nil 9588} 9589 9590func awsRestjson1_deserializeDocumentFileSourceSettings(v **types.FileSourceSettings, value interface{}) error { 9591 if v == nil { 9592 return fmt.Errorf("unexpected nil of type %T", v) 9593 } 9594 if value == nil { 9595 return nil 9596 } 9597 9598 shape, ok := value.(map[string]interface{}) 9599 if !ok { 9600 return fmt.Errorf("unexpected JSON type %v", value) 9601 } 9602 9603 var sv *types.FileSourceSettings 9604 if *v == nil { 9605 sv = &types.FileSourceSettings{} 9606 } else { 9607 sv = *v 9608 } 9609 9610 for key, value := range shape { 9611 switch key { 9612 case "convert608To708": 9613 if value != nil { 9614 jtv, ok := value.(string) 9615 if !ok { 9616 return fmt.Errorf("expected FileSourceConvert608To708 to be of type string, got %T instead", value) 9617 } 9618 sv.Convert608To708 = types.FileSourceConvert608To708(jtv) 9619 } 9620 9621 case "framerate": 9622 if err := awsRestjson1_deserializeDocumentCaptionSourceFramerate(&sv.Framerate, value); err != nil { 9623 return err 9624 } 9625 9626 case "sourceFile": 9627 if value != nil { 9628 jtv, ok := value.(string) 9629 if !ok { 9630 return fmt.Errorf("expected __stringMin14PatternS3SccSCCTtmlTTMLDfxpDFXPStlSTLSrtSRTXmlXMLSmiSMIHttpsSccSCCTtmlTTMLDfxpDFXPStlSTLSrtSRTXmlXMLSmiSMI to be of type string, got %T instead", value) 9631 } 9632 sv.SourceFile = ptr.String(jtv) 9633 } 9634 9635 case "timeDelta": 9636 if value != nil { 9637 jtv, ok := value.(json.Number) 9638 if !ok { 9639 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 9640 } 9641 i64, err := jtv.Int64() 9642 if err != nil { 9643 return err 9644 } 9645 sv.TimeDelta = int32(i64) 9646 } 9647 9648 default: 9649 _, _ = key, value 9650 9651 } 9652 } 9653 *v = sv 9654 return nil 9655} 9656 9657func awsRestjson1_deserializeDocumentForbiddenException(v **types.ForbiddenException, value interface{}) error { 9658 if v == nil { 9659 return fmt.Errorf("unexpected nil of type %T", v) 9660 } 9661 if value == nil { 9662 return nil 9663 } 9664 9665 shape, ok := value.(map[string]interface{}) 9666 if !ok { 9667 return fmt.Errorf("unexpected JSON type %v", value) 9668 } 9669 9670 var sv *types.ForbiddenException 9671 if *v == nil { 9672 sv = &types.ForbiddenException{} 9673 } else { 9674 sv = *v 9675 } 9676 9677 for key, value := range shape { 9678 switch key { 9679 case "message": 9680 if value != nil { 9681 jtv, ok := value.(string) 9682 if !ok { 9683 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 9684 } 9685 sv.Message = ptr.String(jtv) 9686 } 9687 9688 default: 9689 _, _ = key, value 9690 9691 } 9692 } 9693 *v = sv 9694 return nil 9695} 9696 9697func awsRestjson1_deserializeDocumentFrameCaptureSettings(v **types.FrameCaptureSettings, value interface{}) error { 9698 if v == nil { 9699 return fmt.Errorf("unexpected nil of type %T", v) 9700 } 9701 if value == nil { 9702 return nil 9703 } 9704 9705 shape, ok := value.(map[string]interface{}) 9706 if !ok { 9707 return fmt.Errorf("unexpected JSON type %v", value) 9708 } 9709 9710 var sv *types.FrameCaptureSettings 9711 if *v == nil { 9712 sv = &types.FrameCaptureSettings{} 9713 } else { 9714 sv = *v 9715 } 9716 9717 for key, value := range shape { 9718 switch key { 9719 case "framerateDenominator": 9720 if value != nil { 9721 jtv, ok := value.(json.Number) 9722 if !ok { 9723 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 9724 } 9725 i64, err := jtv.Int64() 9726 if err != nil { 9727 return err 9728 } 9729 sv.FramerateDenominator = int32(i64) 9730 } 9731 9732 case "framerateNumerator": 9733 if value != nil { 9734 jtv, ok := value.(json.Number) 9735 if !ok { 9736 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 9737 } 9738 i64, err := jtv.Int64() 9739 if err != nil { 9740 return err 9741 } 9742 sv.FramerateNumerator = int32(i64) 9743 } 9744 9745 case "maxCaptures": 9746 if value != nil { 9747 jtv, ok := value.(json.Number) 9748 if !ok { 9749 return fmt.Errorf("expected __integerMin1Max10000000 to be json.Number, got %T instead", value) 9750 } 9751 i64, err := jtv.Int64() 9752 if err != nil { 9753 return err 9754 } 9755 sv.MaxCaptures = int32(i64) 9756 } 9757 9758 case "quality": 9759 if value != nil { 9760 jtv, ok := value.(json.Number) 9761 if !ok { 9762 return fmt.Errorf("expected __integerMin1Max100 to be json.Number, got %T instead", value) 9763 } 9764 i64, err := jtv.Int64() 9765 if err != nil { 9766 return err 9767 } 9768 sv.Quality = int32(i64) 9769 } 9770 9771 default: 9772 _, _ = key, value 9773 9774 } 9775 } 9776 *v = sv 9777 return nil 9778} 9779 9780func awsRestjson1_deserializeDocumentH264QvbrSettings(v **types.H264QvbrSettings, value interface{}) error { 9781 if v == nil { 9782 return fmt.Errorf("unexpected nil of type %T", v) 9783 } 9784 if value == nil { 9785 return nil 9786 } 9787 9788 shape, ok := value.(map[string]interface{}) 9789 if !ok { 9790 return fmt.Errorf("unexpected JSON type %v", value) 9791 } 9792 9793 var sv *types.H264QvbrSettings 9794 if *v == nil { 9795 sv = &types.H264QvbrSettings{} 9796 } else { 9797 sv = *v 9798 } 9799 9800 for key, value := range shape { 9801 switch key { 9802 case "maxAverageBitrate": 9803 if value != nil { 9804 jtv, ok := value.(json.Number) 9805 if !ok { 9806 return fmt.Errorf("expected __integerMin1000Max1152000000 to be json.Number, got %T instead", value) 9807 } 9808 i64, err := jtv.Int64() 9809 if err != nil { 9810 return err 9811 } 9812 sv.MaxAverageBitrate = int32(i64) 9813 } 9814 9815 case "qvbrQualityLevel": 9816 if value != nil { 9817 jtv, ok := value.(json.Number) 9818 if !ok { 9819 return fmt.Errorf("expected __integerMin1Max10 to be json.Number, got %T instead", value) 9820 } 9821 i64, err := jtv.Int64() 9822 if err != nil { 9823 return err 9824 } 9825 sv.QvbrQualityLevel = int32(i64) 9826 } 9827 9828 case "qvbrQualityLevelFineTune": 9829 if value != nil { 9830 jtv, ok := value.(json.Number) 9831 if !ok { 9832 return fmt.Errorf("expected __doubleMin0Max1 to be json.Number, got %T instead", value) 9833 } 9834 f64, err := jtv.Float64() 9835 if err != nil { 9836 return err 9837 } 9838 sv.QvbrQualityLevelFineTune = f64 9839 } 9840 9841 default: 9842 _, _ = key, value 9843 9844 } 9845 } 9846 *v = sv 9847 return nil 9848} 9849 9850func awsRestjson1_deserializeDocumentH264Settings(v **types.H264Settings, value interface{}) error { 9851 if v == nil { 9852 return fmt.Errorf("unexpected nil of type %T", v) 9853 } 9854 if value == nil { 9855 return nil 9856 } 9857 9858 shape, ok := value.(map[string]interface{}) 9859 if !ok { 9860 return fmt.Errorf("unexpected JSON type %v", value) 9861 } 9862 9863 var sv *types.H264Settings 9864 if *v == nil { 9865 sv = &types.H264Settings{} 9866 } else { 9867 sv = *v 9868 } 9869 9870 for key, value := range shape { 9871 switch key { 9872 case "adaptiveQuantization": 9873 if value != nil { 9874 jtv, ok := value.(string) 9875 if !ok { 9876 return fmt.Errorf("expected H264AdaptiveQuantization to be of type string, got %T instead", value) 9877 } 9878 sv.AdaptiveQuantization = types.H264AdaptiveQuantization(jtv) 9879 } 9880 9881 case "bitrate": 9882 if value != nil { 9883 jtv, ok := value.(json.Number) 9884 if !ok { 9885 return fmt.Errorf("expected __integerMin1000Max1152000000 to be json.Number, got %T instead", value) 9886 } 9887 i64, err := jtv.Int64() 9888 if err != nil { 9889 return err 9890 } 9891 sv.Bitrate = int32(i64) 9892 } 9893 9894 case "codecLevel": 9895 if value != nil { 9896 jtv, ok := value.(string) 9897 if !ok { 9898 return fmt.Errorf("expected H264CodecLevel to be of type string, got %T instead", value) 9899 } 9900 sv.CodecLevel = types.H264CodecLevel(jtv) 9901 } 9902 9903 case "codecProfile": 9904 if value != nil { 9905 jtv, ok := value.(string) 9906 if !ok { 9907 return fmt.Errorf("expected H264CodecProfile to be of type string, got %T instead", value) 9908 } 9909 sv.CodecProfile = types.H264CodecProfile(jtv) 9910 } 9911 9912 case "dynamicSubGop": 9913 if value != nil { 9914 jtv, ok := value.(string) 9915 if !ok { 9916 return fmt.Errorf("expected H264DynamicSubGop to be of type string, got %T instead", value) 9917 } 9918 sv.DynamicSubGop = types.H264DynamicSubGop(jtv) 9919 } 9920 9921 case "entropyEncoding": 9922 if value != nil { 9923 jtv, ok := value.(string) 9924 if !ok { 9925 return fmt.Errorf("expected H264EntropyEncoding to be of type string, got %T instead", value) 9926 } 9927 sv.EntropyEncoding = types.H264EntropyEncoding(jtv) 9928 } 9929 9930 case "fieldEncoding": 9931 if value != nil { 9932 jtv, ok := value.(string) 9933 if !ok { 9934 return fmt.Errorf("expected H264FieldEncoding to be of type string, got %T instead", value) 9935 } 9936 sv.FieldEncoding = types.H264FieldEncoding(jtv) 9937 } 9938 9939 case "flickerAdaptiveQuantization": 9940 if value != nil { 9941 jtv, ok := value.(string) 9942 if !ok { 9943 return fmt.Errorf("expected H264FlickerAdaptiveQuantization to be of type string, got %T instead", value) 9944 } 9945 sv.FlickerAdaptiveQuantization = types.H264FlickerAdaptiveQuantization(jtv) 9946 } 9947 9948 case "framerateControl": 9949 if value != nil { 9950 jtv, ok := value.(string) 9951 if !ok { 9952 return fmt.Errorf("expected H264FramerateControl to be of type string, got %T instead", value) 9953 } 9954 sv.FramerateControl = types.H264FramerateControl(jtv) 9955 } 9956 9957 case "framerateConversionAlgorithm": 9958 if value != nil { 9959 jtv, ok := value.(string) 9960 if !ok { 9961 return fmt.Errorf("expected H264FramerateConversionAlgorithm to be of type string, got %T instead", value) 9962 } 9963 sv.FramerateConversionAlgorithm = types.H264FramerateConversionAlgorithm(jtv) 9964 } 9965 9966 case "framerateDenominator": 9967 if value != nil { 9968 jtv, ok := value.(json.Number) 9969 if !ok { 9970 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 9971 } 9972 i64, err := jtv.Int64() 9973 if err != nil { 9974 return err 9975 } 9976 sv.FramerateDenominator = int32(i64) 9977 } 9978 9979 case "framerateNumerator": 9980 if value != nil { 9981 jtv, ok := value.(json.Number) 9982 if !ok { 9983 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 9984 } 9985 i64, err := jtv.Int64() 9986 if err != nil { 9987 return err 9988 } 9989 sv.FramerateNumerator = int32(i64) 9990 } 9991 9992 case "gopBReference": 9993 if value != nil { 9994 jtv, ok := value.(string) 9995 if !ok { 9996 return fmt.Errorf("expected H264GopBReference to be of type string, got %T instead", value) 9997 } 9998 sv.GopBReference = types.H264GopBReference(jtv) 9999 } 10000 10001 case "gopClosedCadence": 10002 if value != nil { 10003 jtv, ok := value.(json.Number) 10004 if !ok { 10005 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 10006 } 10007 i64, err := jtv.Int64() 10008 if err != nil { 10009 return err 10010 } 10011 sv.GopClosedCadence = int32(i64) 10012 } 10013 10014 case "gopSize": 10015 if value != nil { 10016 jtv, ok := value.(json.Number) 10017 if !ok { 10018 return fmt.Errorf("expected __doubleMin0 to be json.Number, got %T instead", value) 10019 } 10020 f64, err := jtv.Float64() 10021 if err != nil { 10022 return err 10023 } 10024 sv.GopSize = f64 10025 } 10026 10027 case "gopSizeUnits": 10028 if value != nil { 10029 jtv, ok := value.(string) 10030 if !ok { 10031 return fmt.Errorf("expected H264GopSizeUnits to be of type string, got %T instead", value) 10032 } 10033 sv.GopSizeUnits = types.H264GopSizeUnits(jtv) 10034 } 10035 10036 case "hrdBufferInitialFillPercentage": 10037 if value != nil { 10038 jtv, ok := value.(json.Number) 10039 if !ok { 10040 return fmt.Errorf("expected __integerMin0Max100 to be json.Number, got %T instead", value) 10041 } 10042 i64, err := jtv.Int64() 10043 if err != nil { 10044 return err 10045 } 10046 sv.HrdBufferInitialFillPercentage = int32(i64) 10047 } 10048 10049 case "hrdBufferSize": 10050 if value != nil { 10051 jtv, ok := value.(json.Number) 10052 if !ok { 10053 return fmt.Errorf("expected __integerMin0Max1152000000 to be json.Number, got %T instead", value) 10054 } 10055 i64, err := jtv.Int64() 10056 if err != nil { 10057 return err 10058 } 10059 sv.HrdBufferSize = int32(i64) 10060 } 10061 10062 case "interlaceMode": 10063 if value != nil { 10064 jtv, ok := value.(string) 10065 if !ok { 10066 return fmt.Errorf("expected H264InterlaceMode to be of type string, got %T instead", value) 10067 } 10068 sv.InterlaceMode = types.H264InterlaceMode(jtv) 10069 } 10070 10071 case "maxBitrate": 10072 if value != nil { 10073 jtv, ok := value.(json.Number) 10074 if !ok { 10075 return fmt.Errorf("expected __integerMin1000Max1152000000 to be json.Number, got %T instead", value) 10076 } 10077 i64, err := jtv.Int64() 10078 if err != nil { 10079 return err 10080 } 10081 sv.MaxBitrate = int32(i64) 10082 } 10083 10084 case "minIInterval": 10085 if value != nil { 10086 jtv, ok := value.(json.Number) 10087 if !ok { 10088 return fmt.Errorf("expected __integerMin0Max30 to be json.Number, got %T instead", value) 10089 } 10090 i64, err := jtv.Int64() 10091 if err != nil { 10092 return err 10093 } 10094 sv.MinIInterval = int32(i64) 10095 } 10096 10097 case "numberBFramesBetweenReferenceFrames": 10098 if value != nil { 10099 jtv, ok := value.(json.Number) 10100 if !ok { 10101 return fmt.Errorf("expected __integerMin0Max7 to be json.Number, got %T instead", value) 10102 } 10103 i64, err := jtv.Int64() 10104 if err != nil { 10105 return err 10106 } 10107 sv.NumberBFramesBetweenReferenceFrames = int32(i64) 10108 } 10109 10110 case "numberReferenceFrames": 10111 if value != nil { 10112 jtv, ok := value.(json.Number) 10113 if !ok { 10114 return fmt.Errorf("expected __integerMin1Max6 to be json.Number, got %T instead", value) 10115 } 10116 i64, err := jtv.Int64() 10117 if err != nil { 10118 return err 10119 } 10120 sv.NumberReferenceFrames = int32(i64) 10121 } 10122 10123 case "parControl": 10124 if value != nil { 10125 jtv, ok := value.(string) 10126 if !ok { 10127 return fmt.Errorf("expected H264ParControl to be of type string, got %T instead", value) 10128 } 10129 sv.ParControl = types.H264ParControl(jtv) 10130 } 10131 10132 case "parDenominator": 10133 if value != nil { 10134 jtv, ok := value.(json.Number) 10135 if !ok { 10136 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 10137 } 10138 i64, err := jtv.Int64() 10139 if err != nil { 10140 return err 10141 } 10142 sv.ParDenominator = int32(i64) 10143 } 10144 10145 case "parNumerator": 10146 if value != nil { 10147 jtv, ok := value.(json.Number) 10148 if !ok { 10149 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 10150 } 10151 i64, err := jtv.Int64() 10152 if err != nil { 10153 return err 10154 } 10155 sv.ParNumerator = int32(i64) 10156 } 10157 10158 case "qualityTuningLevel": 10159 if value != nil { 10160 jtv, ok := value.(string) 10161 if !ok { 10162 return fmt.Errorf("expected H264QualityTuningLevel to be of type string, got %T instead", value) 10163 } 10164 sv.QualityTuningLevel = types.H264QualityTuningLevel(jtv) 10165 } 10166 10167 case "qvbrSettings": 10168 if err := awsRestjson1_deserializeDocumentH264QvbrSettings(&sv.QvbrSettings, value); err != nil { 10169 return err 10170 } 10171 10172 case "rateControlMode": 10173 if value != nil { 10174 jtv, ok := value.(string) 10175 if !ok { 10176 return fmt.Errorf("expected H264RateControlMode to be of type string, got %T instead", value) 10177 } 10178 sv.RateControlMode = types.H264RateControlMode(jtv) 10179 } 10180 10181 case "repeatPps": 10182 if value != nil { 10183 jtv, ok := value.(string) 10184 if !ok { 10185 return fmt.Errorf("expected H264RepeatPps to be of type string, got %T instead", value) 10186 } 10187 sv.RepeatPps = types.H264RepeatPps(jtv) 10188 } 10189 10190 case "sceneChangeDetect": 10191 if value != nil { 10192 jtv, ok := value.(string) 10193 if !ok { 10194 return fmt.Errorf("expected H264SceneChangeDetect to be of type string, got %T instead", value) 10195 } 10196 sv.SceneChangeDetect = types.H264SceneChangeDetect(jtv) 10197 } 10198 10199 case "slices": 10200 if value != nil { 10201 jtv, ok := value.(json.Number) 10202 if !ok { 10203 return fmt.Errorf("expected __integerMin1Max32 to be json.Number, got %T instead", value) 10204 } 10205 i64, err := jtv.Int64() 10206 if err != nil { 10207 return err 10208 } 10209 sv.Slices = int32(i64) 10210 } 10211 10212 case "slowPal": 10213 if value != nil { 10214 jtv, ok := value.(string) 10215 if !ok { 10216 return fmt.Errorf("expected H264SlowPal to be of type string, got %T instead", value) 10217 } 10218 sv.SlowPal = types.H264SlowPal(jtv) 10219 } 10220 10221 case "softness": 10222 if value != nil { 10223 jtv, ok := value.(json.Number) 10224 if !ok { 10225 return fmt.Errorf("expected __integerMin0Max128 to be json.Number, got %T instead", value) 10226 } 10227 i64, err := jtv.Int64() 10228 if err != nil { 10229 return err 10230 } 10231 sv.Softness = int32(i64) 10232 } 10233 10234 case "spatialAdaptiveQuantization": 10235 if value != nil { 10236 jtv, ok := value.(string) 10237 if !ok { 10238 return fmt.Errorf("expected H264SpatialAdaptiveQuantization to be of type string, got %T instead", value) 10239 } 10240 sv.SpatialAdaptiveQuantization = types.H264SpatialAdaptiveQuantization(jtv) 10241 } 10242 10243 case "syntax": 10244 if value != nil { 10245 jtv, ok := value.(string) 10246 if !ok { 10247 return fmt.Errorf("expected H264Syntax to be of type string, got %T instead", value) 10248 } 10249 sv.Syntax = types.H264Syntax(jtv) 10250 } 10251 10252 case "telecine": 10253 if value != nil { 10254 jtv, ok := value.(string) 10255 if !ok { 10256 return fmt.Errorf("expected H264Telecine to be of type string, got %T instead", value) 10257 } 10258 sv.Telecine = types.H264Telecine(jtv) 10259 } 10260 10261 case "temporalAdaptiveQuantization": 10262 if value != nil { 10263 jtv, ok := value.(string) 10264 if !ok { 10265 return fmt.Errorf("expected H264TemporalAdaptiveQuantization to be of type string, got %T instead", value) 10266 } 10267 sv.TemporalAdaptiveQuantization = types.H264TemporalAdaptiveQuantization(jtv) 10268 } 10269 10270 case "unregisteredSeiTimecode": 10271 if value != nil { 10272 jtv, ok := value.(string) 10273 if !ok { 10274 return fmt.Errorf("expected H264UnregisteredSeiTimecode to be of type string, got %T instead", value) 10275 } 10276 sv.UnregisteredSeiTimecode = types.H264UnregisteredSeiTimecode(jtv) 10277 } 10278 10279 default: 10280 _, _ = key, value 10281 10282 } 10283 } 10284 *v = sv 10285 return nil 10286} 10287 10288func awsRestjson1_deserializeDocumentH265QvbrSettings(v **types.H265QvbrSettings, value interface{}) error { 10289 if v == nil { 10290 return fmt.Errorf("unexpected nil of type %T", v) 10291 } 10292 if value == nil { 10293 return nil 10294 } 10295 10296 shape, ok := value.(map[string]interface{}) 10297 if !ok { 10298 return fmt.Errorf("unexpected JSON type %v", value) 10299 } 10300 10301 var sv *types.H265QvbrSettings 10302 if *v == nil { 10303 sv = &types.H265QvbrSettings{} 10304 } else { 10305 sv = *v 10306 } 10307 10308 for key, value := range shape { 10309 switch key { 10310 case "maxAverageBitrate": 10311 if value != nil { 10312 jtv, ok := value.(json.Number) 10313 if !ok { 10314 return fmt.Errorf("expected __integerMin1000Max1466400000 to be json.Number, got %T instead", value) 10315 } 10316 i64, err := jtv.Int64() 10317 if err != nil { 10318 return err 10319 } 10320 sv.MaxAverageBitrate = int32(i64) 10321 } 10322 10323 case "qvbrQualityLevel": 10324 if value != nil { 10325 jtv, ok := value.(json.Number) 10326 if !ok { 10327 return fmt.Errorf("expected __integerMin1Max10 to be json.Number, got %T instead", value) 10328 } 10329 i64, err := jtv.Int64() 10330 if err != nil { 10331 return err 10332 } 10333 sv.QvbrQualityLevel = int32(i64) 10334 } 10335 10336 case "qvbrQualityLevelFineTune": 10337 if value != nil { 10338 jtv, ok := value.(json.Number) 10339 if !ok { 10340 return fmt.Errorf("expected __doubleMin0Max1 to be json.Number, got %T instead", value) 10341 } 10342 f64, err := jtv.Float64() 10343 if err != nil { 10344 return err 10345 } 10346 sv.QvbrQualityLevelFineTune = f64 10347 } 10348 10349 default: 10350 _, _ = key, value 10351 10352 } 10353 } 10354 *v = sv 10355 return nil 10356} 10357 10358func awsRestjson1_deserializeDocumentH265Settings(v **types.H265Settings, value interface{}) error { 10359 if v == nil { 10360 return fmt.Errorf("unexpected nil of type %T", v) 10361 } 10362 if value == nil { 10363 return nil 10364 } 10365 10366 shape, ok := value.(map[string]interface{}) 10367 if !ok { 10368 return fmt.Errorf("unexpected JSON type %v", value) 10369 } 10370 10371 var sv *types.H265Settings 10372 if *v == nil { 10373 sv = &types.H265Settings{} 10374 } else { 10375 sv = *v 10376 } 10377 10378 for key, value := range shape { 10379 switch key { 10380 case "adaptiveQuantization": 10381 if value != nil { 10382 jtv, ok := value.(string) 10383 if !ok { 10384 return fmt.Errorf("expected H265AdaptiveQuantization to be of type string, got %T instead", value) 10385 } 10386 sv.AdaptiveQuantization = types.H265AdaptiveQuantization(jtv) 10387 } 10388 10389 case "alternateTransferFunctionSei": 10390 if value != nil { 10391 jtv, ok := value.(string) 10392 if !ok { 10393 return fmt.Errorf("expected H265AlternateTransferFunctionSei to be of type string, got %T instead", value) 10394 } 10395 sv.AlternateTransferFunctionSei = types.H265AlternateTransferFunctionSei(jtv) 10396 } 10397 10398 case "bitrate": 10399 if value != nil { 10400 jtv, ok := value.(json.Number) 10401 if !ok { 10402 return fmt.Errorf("expected __integerMin1000Max1466400000 to be json.Number, got %T instead", value) 10403 } 10404 i64, err := jtv.Int64() 10405 if err != nil { 10406 return err 10407 } 10408 sv.Bitrate = int32(i64) 10409 } 10410 10411 case "codecLevel": 10412 if value != nil { 10413 jtv, ok := value.(string) 10414 if !ok { 10415 return fmt.Errorf("expected H265CodecLevel to be of type string, got %T instead", value) 10416 } 10417 sv.CodecLevel = types.H265CodecLevel(jtv) 10418 } 10419 10420 case "codecProfile": 10421 if value != nil { 10422 jtv, ok := value.(string) 10423 if !ok { 10424 return fmt.Errorf("expected H265CodecProfile to be of type string, got %T instead", value) 10425 } 10426 sv.CodecProfile = types.H265CodecProfile(jtv) 10427 } 10428 10429 case "dynamicSubGop": 10430 if value != nil { 10431 jtv, ok := value.(string) 10432 if !ok { 10433 return fmt.Errorf("expected H265DynamicSubGop to be of type string, got %T instead", value) 10434 } 10435 sv.DynamicSubGop = types.H265DynamicSubGop(jtv) 10436 } 10437 10438 case "flickerAdaptiveQuantization": 10439 if value != nil { 10440 jtv, ok := value.(string) 10441 if !ok { 10442 return fmt.Errorf("expected H265FlickerAdaptiveQuantization to be of type string, got %T instead", value) 10443 } 10444 sv.FlickerAdaptiveQuantization = types.H265FlickerAdaptiveQuantization(jtv) 10445 } 10446 10447 case "framerateControl": 10448 if value != nil { 10449 jtv, ok := value.(string) 10450 if !ok { 10451 return fmt.Errorf("expected H265FramerateControl to be of type string, got %T instead", value) 10452 } 10453 sv.FramerateControl = types.H265FramerateControl(jtv) 10454 } 10455 10456 case "framerateConversionAlgorithm": 10457 if value != nil { 10458 jtv, ok := value.(string) 10459 if !ok { 10460 return fmt.Errorf("expected H265FramerateConversionAlgorithm to be of type string, got %T instead", value) 10461 } 10462 sv.FramerateConversionAlgorithm = types.H265FramerateConversionAlgorithm(jtv) 10463 } 10464 10465 case "framerateDenominator": 10466 if value != nil { 10467 jtv, ok := value.(json.Number) 10468 if !ok { 10469 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 10470 } 10471 i64, err := jtv.Int64() 10472 if err != nil { 10473 return err 10474 } 10475 sv.FramerateDenominator = int32(i64) 10476 } 10477 10478 case "framerateNumerator": 10479 if value != nil { 10480 jtv, ok := value.(json.Number) 10481 if !ok { 10482 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 10483 } 10484 i64, err := jtv.Int64() 10485 if err != nil { 10486 return err 10487 } 10488 sv.FramerateNumerator = int32(i64) 10489 } 10490 10491 case "gopBReference": 10492 if value != nil { 10493 jtv, ok := value.(string) 10494 if !ok { 10495 return fmt.Errorf("expected H265GopBReference to be of type string, got %T instead", value) 10496 } 10497 sv.GopBReference = types.H265GopBReference(jtv) 10498 } 10499 10500 case "gopClosedCadence": 10501 if value != nil { 10502 jtv, ok := value.(json.Number) 10503 if !ok { 10504 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 10505 } 10506 i64, err := jtv.Int64() 10507 if err != nil { 10508 return err 10509 } 10510 sv.GopClosedCadence = int32(i64) 10511 } 10512 10513 case "gopSize": 10514 if value != nil { 10515 jtv, ok := value.(json.Number) 10516 if !ok { 10517 return fmt.Errorf("expected __doubleMin0 to be json.Number, got %T instead", value) 10518 } 10519 f64, err := jtv.Float64() 10520 if err != nil { 10521 return err 10522 } 10523 sv.GopSize = f64 10524 } 10525 10526 case "gopSizeUnits": 10527 if value != nil { 10528 jtv, ok := value.(string) 10529 if !ok { 10530 return fmt.Errorf("expected H265GopSizeUnits to be of type string, got %T instead", value) 10531 } 10532 sv.GopSizeUnits = types.H265GopSizeUnits(jtv) 10533 } 10534 10535 case "hrdBufferInitialFillPercentage": 10536 if value != nil { 10537 jtv, ok := value.(json.Number) 10538 if !ok { 10539 return fmt.Errorf("expected __integerMin0Max100 to be json.Number, got %T instead", value) 10540 } 10541 i64, err := jtv.Int64() 10542 if err != nil { 10543 return err 10544 } 10545 sv.HrdBufferInitialFillPercentage = int32(i64) 10546 } 10547 10548 case "hrdBufferSize": 10549 if value != nil { 10550 jtv, ok := value.(json.Number) 10551 if !ok { 10552 return fmt.Errorf("expected __integerMin0Max1466400000 to be json.Number, got %T instead", value) 10553 } 10554 i64, err := jtv.Int64() 10555 if err != nil { 10556 return err 10557 } 10558 sv.HrdBufferSize = int32(i64) 10559 } 10560 10561 case "interlaceMode": 10562 if value != nil { 10563 jtv, ok := value.(string) 10564 if !ok { 10565 return fmt.Errorf("expected H265InterlaceMode to be of type string, got %T instead", value) 10566 } 10567 sv.InterlaceMode = types.H265InterlaceMode(jtv) 10568 } 10569 10570 case "maxBitrate": 10571 if value != nil { 10572 jtv, ok := value.(json.Number) 10573 if !ok { 10574 return fmt.Errorf("expected __integerMin1000Max1466400000 to be json.Number, got %T instead", value) 10575 } 10576 i64, err := jtv.Int64() 10577 if err != nil { 10578 return err 10579 } 10580 sv.MaxBitrate = int32(i64) 10581 } 10582 10583 case "minIInterval": 10584 if value != nil { 10585 jtv, ok := value.(json.Number) 10586 if !ok { 10587 return fmt.Errorf("expected __integerMin0Max30 to be json.Number, got %T instead", value) 10588 } 10589 i64, err := jtv.Int64() 10590 if err != nil { 10591 return err 10592 } 10593 sv.MinIInterval = int32(i64) 10594 } 10595 10596 case "numberBFramesBetweenReferenceFrames": 10597 if value != nil { 10598 jtv, ok := value.(json.Number) 10599 if !ok { 10600 return fmt.Errorf("expected __integerMin0Max7 to be json.Number, got %T instead", value) 10601 } 10602 i64, err := jtv.Int64() 10603 if err != nil { 10604 return err 10605 } 10606 sv.NumberBFramesBetweenReferenceFrames = int32(i64) 10607 } 10608 10609 case "numberReferenceFrames": 10610 if value != nil { 10611 jtv, ok := value.(json.Number) 10612 if !ok { 10613 return fmt.Errorf("expected __integerMin1Max6 to be json.Number, got %T instead", value) 10614 } 10615 i64, err := jtv.Int64() 10616 if err != nil { 10617 return err 10618 } 10619 sv.NumberReferenceFrames = int32(i64) 10620 } 10621 10622 case "parControl": 10623 if value != nil { 10624 jtv, ok := value.(string) 10625 if !ok { 10626 return fmt.Errorf("expected H265ParControl to be of type string, got %T instead", value) 10627 } 10628 sv.ParControl = types.H265ParControl(jtv) 10629 } 10630 10631 case "parDenominator": 10632 if value != nil { 10633 jtv, ok := value.(json.Number) 10634 if !ok { 10635 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 10636 } 10637 i64, err := jtv.Int64() 10638 if err != nil { 10639 return err 10640 } 10641 sv.ParDenominator = int32(i64) 10642 } 10643 10644 case "parNumerator": 10645 if value != nil { 10646 jtv, ok := value.(json.Number) 10647 if !ok { 10648 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 10649 } 10650 i64, err := jtv.Int64() 10651 if err != nil { 10652 return err 10653 } 10654 sv.ParNumerator = int32(i64) 10655 } 10656 10657 case "qualityTuningLevel": 10658 if value != nil { 10659 jtv, ok := value.(string) 10660 if !ok { 10661 return fmt.Errorf("expected H265QualityTuningLevel to be of type string, got %T instead", value) 10662 } 10663 sv.QualityTuningLevel = types.H265QualityTuningLevel(jtv) 10664 } 10665 10666 case "qvbrSettings": 10667 if err := awsRestjson1_deserializeDocumentH265QvbrSettings(&sv.QvbrSettings, value); err != nil { 10668 return err 10669 } 10670 10671 case "rateControlMode": 10672 if value != nil { 10673 jtv, ok := value.(string) 10674 if !ok { 10675 return fmt.Errorf("expected H265RateControlMode to be of type string, got %T instead", value) 10676 } 10677 sv.RateControlMode = types.H265RateControlMode(jtv) 10678 } 10679 10680 case "sampleAdaptiveOffsetFilterMode": 10681 if value != nil { 10682 jtv, ok := value.(string) 10683 if !ok { 10684 return fmt.Errorf("expected H265SampleAdaptiveOffsetFilterMode to be of type string, got %T instead", value) 10685 } 10686 sv.SampleAdaptiveOffsetFilterMode = types.H265SampleAdaptiveOffsetFilterMode(jtv) 10687 } 10688 10689 case "sceneChangeDetect": 10690 if value != nil { 10691 jtv, ok := value.(string) 10692 if !ok { 10693 return fmt.Errorf("expected H265SceneChangeDetect to be of type string, got %T instead", value) 10694 } 10695 sv.SceneChangeDetect = types.H265SceneChangeDetect(jtv) 10696 } 10697 10698 case "slices": 10699 if value != nil { 10700 jtv, ok := value.(json.Number) 10701 if !ok { 10702 return fmt.Errorf("expected __integerMin1Max32 to be json.Number, got %T instead", value) 10703 } 10704 i64, err := jtv.Int64() 10705 if err != nil { 10706 return err 10707 } 10708 sv.Slices = int32(i64) 10709 } 10710 10711 case "slowPal": 10712 if value != nil { 10713 jtv, ok := value.(string) 10714 if !ok { 10715 return fmt.Errorf("expected H265SlowPal to be of type string, got %T instead", value) 10716 } 10717 sv.SlowPal = types.H265SlowPal(jtv) 10718 } 10719 10720 case "spatialAdaptiveQuantization": 10721 if value != nil { 10722 jtv, ok := value.(string) 10723 if !ok { 10724 return fmt.Errorf("expected H265SpatialAdaptiveQuantization to be of type string, got %T instead", value) 10725 } 10726 sv.SpatialAdaptiveQuantization = types.H265SpatialAdaptiveQuantization(jtv) 10727 } 10728 10729 case "telecine": 10730 if value != nil { 10731 jtv, ok := value.(string) 10732 if !ok { 10733 return fmt.Errorf("expected H265Telecine to be of type string, got %T instead", value) 10734 } 10735 sv.Telecine = types.H265Telecine(jtv) 10736 } 10737 10738 case "temporalAdaptiveQuantization": 10739 if value != nil { 10740 jtv, ok := value.(string) 10741 if !ok { 10742 return fmt.Errorf("expected H265TemporalAdaptiveQuantization to be of type string, got %T instead", value) 10743 } 10744 sv.TemporalAdaptiveQuantization = types.H265TemporalAdaptiveQuantization(jtv) 10745 } 10746 10747 case "temporalIds": 10748 if value != nil { 10749 jtv, ok := value.(string) 10750 if !ok { 10751 return fmt.Errorf("expected H265TemporalIds to be of type string, got %T instead", value) 10752 } 10753 sv.TemporalIds = types.H265TemporalIds(jtv) 10754 } 10755 10756 case "tiles": 10757 if value != nil { 10758 jtv, ok := value.(string) 10759 if !ok { 10760 return fmt.Errorf("expected H265Tiles to be of type string, got %T instead", value) 10761 } 10762 sv.Tiles = types.H265Tiles(jtv) 10763 } 10764 10765 case "unregisteredSeiTimecode": 10766 if value != nil { 10767 jtv, ok := value.(string) 10768 if !ok { 10769 return fmt.Errorf("expected H265UnregisteredSeiTimecode to be of type string, got %T instead", value) 10770 } 10771 sv.UnregisteredSeiTimecode = types.H265UnregisteredSeiTimecode(jtv) 10772 } 10773 10774 case "writeMp4PackagingType": 10775 if value != nil { 10776 jtv, ok := value.(string) 10777 if !ok { 10778 return fmt.Errorf("expected H265WriteMp4PackagingType to be of type string, got %T instead", value) 10779 } 10780 sv.WriteMp4PackagingType = types.H265WriteMp4PackagingType(jtv) 10781 } 10782 10783 default: 10784 _, _ = key, value 10785 10786 } 10787 } 10788 *v = sv 10789 return nil 10790} 10791 10792func awsRestjson1_deserializeDocumentHdr10Metadata(v **types.Hdr10Metadata, value interface{}) error { 10793 if v == nil { 10794 return fmt.Errorf("unexpected nil of type %T", v) 10795 } 10796 if value == nil { 10797 return nil 10798 } 10799 10800 shape, ok := value.(map[string]interface{}) 10801 if !ok { 10802 return fmt.Errorf("unexpected JSON type %v", value) 10803 } 10804 10805 var sv *types.Hdr10Metadata 10806 if *v == nil { 10807 sv = &types.Hdr10Metadata{} 10808 } else { 10809 sv = *v 10810 } 10811 10812 for key, value := range shape { 10813 switch key { 10814 case "bluePrimaryX": 10815 if value != nil { 10816 jtv, ok := value.(json.Number) 10817 if !ok { 10818 return fmt.Errorf("expected __integerMin0Max50000 to be json.Number, got %T instead", value) 10819 } 10820 i64, err := jtv.Int64() 10821 if err != nil { 10822 return err 10823 } 10824 sv.BluePrimaryX = int32(i64) 10825 } 10826 10827 case "bluePrimaryY": 10828 if value != nil { 10829 jtv, ok := value.(json.Number) 10830 if !ok { 10831 return fmt.Errorf("expected __integerMin0Max50000 to be json.Number, got %T instead", value) 10832 } 10833 i64, err := jtv.Int64() 10834 if err != nil { 10835 return err 10836 } 10837 sv.BluePrimaryY = int32(i64) 10838 } 10839 10840 case "greenPrimaryX": 10841 if value != nil { 10842 jtv, ok := value.(json.Number) 10843 if !ok { 10844 return fmt.Errorf("expected __integerMin0Max50000 to be json.Number, got %T instead", value) 10845 } 10846 i64, err := jtv.Int64() 10847 if err != nil { 10848 return err 10849 } 10850 sv.GreenPrimaryX = int32(i64) 10851 } 10852 10853 case "greenPrimaryY": 10854 if value != nil { 10855 jtv, ok := value.(json.Number) 10856 if !ok { 10857 return fmt.Errorf("expected __integerMin0Max50000 to be json.Number, got %T instead", value) 10858 } 10859 i64, err := jtv.Int64() 10860 if err != nil { 10861 return err 10862 } 10863 sv.GreenPrimaryY = int32(i64) 10864 } 10865 10866 case "maxContentLightLevel": 10867 if value != nil { 10868 jtv, ok := value.(json.Number) 10869 if !ok { 10870 return fmt.Errorf("expected __integerMin0Max65535 to be json.Number, got %T instead", value) 10871 } 10872 i64, err := jtv.Int64() 10873 if err != nil { 10874 return err 10875 } 10876 sv.MaxContentLightLevel = int32(i64) 10877 } 10878 10879 case "maxFrameAverageLightLevel": 10880 if value != nil { 10881 jtv, ok := value.(json.Number) 10882 if !ok { 10883 return fmt.Errorf("expected __integerMin0Max65535 to be json.Number, got %T instead", value) 10884 } 10885 i64, err := jtv.Int64() 10886 if err != nil { 10887 return err 10888 } 10889 sv.MaxFrameAverageLightLevel = int32(i64) 10890 } 10891 10892 case "maxLuminance": 10893 if value != nil { 10894 jtv, ok := value.(json.Number) 10895 if !ok { 10896 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 10897 } 10898 i64, err := jtv.Int64() 10899 if err != nil { 10900 return err 10901 } 10902 sv.MaxLuminance = int32(i64) 10903 } 10904 10905 case "minLuminance": 10906 if value != nil { 10907 jtv, ok := value.(json.Number) 10908 if !ok { 10909 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 10910 } 10911 i64, err := jtv.Int64() 10912 if err != nil { 10913 return err 10914 } 10915 sv.MinLuminance = int32(i64) 10916 } 10917 10918 case "redPrimaryX": 10919 if value != nil { 10920 jtv, ok := value.(json.Number) 10921 if !ok { 10922 return fmt.Errorf("expected __integerMin0Max50000 to be json.Number, got %T instead", value) 10923 } 10924 i64, err := jtv.Int64() 10925 if err != nil { 10926 return err 10927 } 10928 sv.RedPrimaryX = int32(i64) 10929 } 10930 10931 case "redPrimaryY": 10932 if value != nil { 10933 jtv, ok := value.(json.Number) 10934 if !ok { 10935 return fmt.Errorf("expected __integerMin0Max50000 to be json.Number, got %T instead", value) 10936 } 10937 i64, err := jtv.Int64() 10938 if err != nil { 10939 return err 10940 } 10941 sv.RedPrimaryY = int32(i64) 10942 } 10943 10944 case "whitePointX": 10945 if value != nil { 10946 jtv, ok := value.(json.Number) 10947 if !ok { 10948 return fmt.Errorf("expected __integerMin0Max50000 to be json.Number, got %T instead", value) 10949 } 10950 i64, err := jtv.Int64() 10951 if err != nil { 10952 return err 10953 } 10954 sv.WhitePointX = int32(i64) 10955 } 10956 10957 case "whitePointY": 10958 if value != nil { 10959 jtv, ok := value.(json.Number) 10960 if !ok { 10961 return fmt.Errorf("expected __integerMin0Max50000 to be json.Number, got %T instead", value) 10962 } 10963 i64, err := jtv.Int64() 10964 if err != nil { 10965 return err 10966 } 10967 sv.WhitePointY = int32(i64) 10968 } 10969 10970 default: 10971 _, _ = key, value 10972 10973 } 10974 } 10975 *v = sv 10976 return nil 10977} 10978 10979func awsRestjson1_deserializeDocumentHlsAdditionalManifest(v **types.HlsAdditionalManifest, value interface{}) error { 10980 if v == nil { 10981 return fmt.Errorf("unexpected nil of type %T", v) 10982 } 10983 if value == nil { 10984 return nil 10985 } 10986 10987 shape, ok := value.(map[string]interface{}) 10988 if !ok { 10989 return fmt.Errorf("unexpected JSON type %v", value) 10990 } 10991 10992 var sv *types.HlsAdditionalManifest 10993 if *v == nil { 10994 sv = &types.HlsAdditionalManifest{} 10995 } else { 10996 sv = *v 10997 } 10998 10999 for key, value := range shape { 11000 switch key { 11001 case "manifestNameModifier": 11002 if value != nil { 11003 jtv, ok := value.(string) 11004 if !ok { 11005 return fmt.Errorf("expected __stringMin1 to be of type string, got %T instead", value) 11006 } 11007 sv.ManifestNameModifier = ptr.String(jtv) 11008 } 11009 11010 case "selectedOutputs": 11011 if err := awsRestjson1_deserializeDocument__listOf__stringMin1(&sv.SelectedOutputs, value); err != nil { 11012 return err 11013 } 11014 11015 default: 11016 _, _ = key, value 11017 11018 } 11019 } 11020 *v = sv 11021 return nil 11022} 11023 11024func awsRestjson1_deserializeDocumentHlsCaptionLanguageMapping(v **types.HlsCaptionLanguageMapping, value interface{}) error { 11025 if v == nil { 11026 return fmt.Errorf("unexpected nil of type %T", v) 11027 } 11028 if value == nil { 11029 return nil 11030 } 11031 11032 shape, ok := value.(map[string]interface{}) 11033 if !ok { 11034 return fmt.Errorf("unexpected JSON type %v", value) 11035 } 11036 11037 var sv *types.HlsCaptionLanguageMapping 11038 if *v == nil { 11039 sv = &types.HlsCaptionLanguageMapping{} 11040 } else { 11041 sv = *v 11042 } 11043 11044 for key, value := range shape { 11045 switch key { 11046 case "captionChannel": 11047 if value != nil { 11048 jtv, ok := value.(json.Number) 11049 if !ok { 11050 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 11051 } 11052 i64, err := jtv.Int64() 11053 if err != nil { 11054 return err 11055 } 11056 sv.CaptionChannel = int32(i64) 11057 } 11058 11059 case "customLanguageCode": 11060 if value != nil { 11061 jtv, ok := value.(string) 11062 if !ok { 11063 return fmt.Errorf("expected __stringMin3Max3PatternAZaZ3 to be of type string, got %T instead", value) 11064 } 11065 sv.CustomLanguageCode = ptr.String(jtv) 11066 } 11067 11068 case "languageCode": 11069 if value != nil { 11070 jtv, ok := value.(string) 11071 if !ok { 11072 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 11073 } 11074 sv.LanguageCode = types.LanguageCode(jtv) 11075 } 11076 11077 case "languageDescription": 11078 if value != nil { 11079 jtv, ok := value.(string) 11080 if !ok { 11081 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11082 } 11083 sv.LanguageDescription = ptr.String(jtv) 11084 } 11085 11086 default: 11087 _, _ = key, value 11088 11089 } 11090 } 11091 *v = sv 11092 return nil 11093} 11094 11095func awsRestjson1_deserializeDocumentHlsEncryptionSettings(v **types.HlsEncryptionSettings, value interface{}) error { 11096 if v == nil { 11097 return fmt.Errorf("unexpected nil of type %T", v) 11098 } 11099 if value == nil { 11100 return nil 11101 } 11102 11103 shape, ok := value.(map[string]interface{}) 11104 if !ok { 11105 return fmt.Errorf("unexpected JSON type %v", value) 11106 } 11107 11108 var sv *types.HlsEncryptionSettings 11109 if *v == nil { 11110 sv = &types.HlsEncryptionSettings{} 11111 } else { 11112 sv = *v 11113 } 11114 11115 for key, value := range shape { 11116 switch key { 11117 case "constantInitializationVector": 11118 if value != nil { 11119 jtv, ok := value.(string) 11120 if !ok { 11121 return fmt.Errorf("expected __stringMin32Max32Pattern09aFAF32 to be of type string, got %T instead", value) 11122 } 11123 sv.ConstantInitializationVector = ptr.String(jtv) 11124 } 11125 11126 case "encryptionMethod": 11127 if value != nil { 11128 jtv, ok := value.(string) 11129 if !ok { 11130 return fmt.Errorf("expected HlsEncryptionType to be of type string, got %T instead", value) 11131 } 11132 sv.EncryptionMethod = types.HlsEncryptionType(jtv) 11133 } 11134 11135 case "initializationVectorInManifest": 11136 if value != nil { 11137 jtv, ok := value.(string) 11138 if !ok { 11139 return fmt.Errorf("expected HlsInitializationVectorInManifest to be of type string, got %T instead", value) 11140 } 11141 sv.InitializationVectorInManifest = types.HlsInitializationVectorInManifest(jtv) 11142 } 11143 11144 case "offlineEncrypted": 11145 if value != nil { 11146 jtv, ok := value.(string) 11147 if !ok { 11148 return fmt.Errorf("expected HlsOfflineEncrypted to be of type string, got %T instead", value) 11149 } 11150 sv.OfflineEncrypted = types.HlsOfflineEncrypted(jtv) 11151 } 11152 11153 case "spekeKeyProvider": 11154 if err := awsRestjson1_deserializeDocumentSpekeKeyProvider(&sv.SpekeKeyProvider, value); err != nil { 11155 return err 11156 } 11157 11158 case "staticKeyProvider": 11159 if err := awsRestjson1_deserializeDocumentStaticKeyProvider(&sv.StaticKeyProvider, value); err != nil { 11160 return err 11161 } 11162 11163 case "type": 11164 if value != nil { 11165 jtv, ok := value.(string) 11166 if !ok { 11167 return fmt.Errorf("expected HlsKeyProviderType to be of type string, got %T instead", value) 11168 } 11169 sv.Type = types.HlsKeyProviderType(jtv) 11170 } 11171 11172 default: 11173 _, _ = key, value 11174 11175 } 11176 } 11177 *v = sv 11178 return nil 11179} 11180 11181func awsRestjson1_deserializeDocumentHlsGroupSettings(v **types.HlsGroupSettings, value interface{}) error { 11182 if v == nil { 11183 return fmt.Errorf("unexpected nil of type %T", v) 11184 } 11185 if value == nil { 11186 return nil 11187 } 11188 11189 shape, ok := value.(map[string]interface{}) 11190 if !ok { 11191 return fmt.Errorf("unexpected JSON type %v", value) 11192 } 11193 11194 var sv *types.HlsGroupSettings 11195 if *v == nil { 11196 sv = &types.HlsGroupSettings{} 11197 } else { 11198 sv = *v 11199 } 11200 11201 for key, value := range shape { 11202 switch key { 11203 case "additionalManifests": 11204 if err := awsRestjson1_deserializeDocument__listOfHlsAdditionalManifest(&sv.AdditionalManifests, value); err != nil { 11205 return err 11206 } 11207 11208 case "adMarkers": 11209 if err := awsRestjson1_deserializeDocument__listOfHlsAdMarkers(&sv.AdMarkers, value); err != nil { 11210 return err 11211 } 11212 11213 case "audioOnlyHeader": 11214 if value != nil { 11215 jtv, ok := value.(string) 11216 if !ok { 11217 return fmt.Errorf("expected HlsAudioOnlyHeader to be of type string, got %T instead", value) 11218 } 11219 sv.AudioOnlyHeader = types.HlsAudioOnlyHeader(jtv) 11220 } 11221 11222 case "baseUrl": 11223 if value != nil { 11224 jtv, ok := value.(string) 11225 if !ok { 11226 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11227 } 11228 sv.BaseUrl = ptr.String(jtv) 11229 } 11230 11231 case "captionLanguageMappings": 11232 if err := awsRestjson1_deserializeDocument__listOfHlsCaptionLanguageMapping(&sv.CaptionLanguageMappings, value); err != nil { 11233 return err 11234 } 11235 11236 case "captionLanguageSetting": 11237 if value != nil { 11238 jtv, ok := value.(string) 11239 if !ok { 11240 return fmt.Errorf("expected HlsCaptionLanguageSetting to be of type string, got %T instead", value) 11241 } 11242 sv.CaptionLanguageSetting = types.HlsCaptionLanguageSetting(jtv) 11243 } 11244 11245 case "clientCache": 11246 if value != nil { 11247 jtv, ok := value.(string) 11248 if !ok { 11249 return fmt.Errorf("expected HlsClientCache to be of type string, got %T instead", value) 11250 } 11251 sv.ClientCache = types.HlsClientCache(jtv) 11252 } 11253 11254 case "codecSpecification": 11255 if value != nil { 11256 jtv, ok := value.(string) 11257 if !ok { 11258 return fmt.Errorf("expected HlsCodecSpecification to be of type string, got %T instead", value) 11259 } 11260 sv.CodecSpecification = types.HlsCodecSpecification(jtv) 11261 } 11262 11263 case "destination": 11264 if value != nil { 11265 jtv, ok := value.(string) 11266 if !ok { 11267 return fmt.Errorf("expected __stringPatternS3 to be of type string, got %T instead", value) 11268 } 11269 sv.Destination = ptr.String(jtv) 11270 } 11271 11272 case "destinationSettings": 11273 if err := awsRestjson1_deserializeDocumentDestinationSettings(&sv.DestinationSettings, value); err != nil { 11274 return err 11275 } 11276 11277 case "directoryStructure": 11278 if value != nil { 11279 jtv, ok := value.(string) 11280 if !ok { 11281 return fmt.Errorf("expected HlsDirectoryStructure to be of type string, got %T instead", value) 11282 } 11283 sv.DirectoryStructure = types.HlsDirectoryStructure(jtv) 11284 } 11285 11286 case "encryption": 11287 if err := awsRestjson1_deserializeDocumentHlsEncryptionSettings(&sv.Encryption, value); err != nil { 11288 return err 11289 } 11290 11291 case "manifestCompression": 11292 if value != nil { 11293 jtv, ok := value.(string) 11294 if !ok { 11295 return fmt.Errorf("expected HlsManifestCompression to be of type string, got %T instead", value) 11296 } 11297 sv.ManifestCompression = types.HlsManifestCompression(jtv) 11298 } 11299 11300 case "manifestDurationFormat": 11301 if value != nil { 11302 jtv, ok := value.(string) 11303 if !ok { 11304 return fmt.Errorf("expected HlsManifestDurationFormat to be of type string, got %T instead", value) 11305 } 11306 sv.ManifestDurationFormat = types.HlsManifestDurationFormat(jtv) 11307 } 11308 11309 case "minFinalSegmentLength": 11310 if value != nil { 11311 jtv, ok := value.(json.Number) 11312 if !ok { 11313 return fmt.Errorf("expected __doubleMin0Max2147483647 to be json.Number, got %T instead", value) 11314 } 11315 f64, err := jtv.Float64() 11316 if err != nil { 11317 return err 11318 } 11319 sv.MinFinalSegmentLength = f64 11320 } 11321 11322 case "minSegmentLength": 11323 if value != nil { 11324 jtv, ok := value.(json.Number) 11325 if !ok { 11326 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 11327 } 11328 i64, err := jtv.Int64() 11329 if err != nil { 11330 return err 11331 } 11332 sv.MinSegmentLength = int32(i64) 11333 } 11334 11335 case "outputSelection": 11336 if value != nil { 11337 jtv, ok := value.(string) 11338 if !ok { 11339 return fmt.Errorf("expected HlsOutputSelection to be of type string, got %T instead", value) 11340 } 11341 sv.OutputSelection = types.HlsOutputSelection(jtv) 11342 } 11343 11344 case "programDateTime": 11345 if value != nil { 11346 jtv, ok := value.(string) 11347 if !ok { 11348 return fmt.Errorf("expected HlsProgramDateTime to be of type string, got %T instead", value) 11349 } 11350 sv.ProgramDateTime = types.HlsProgramDateTime(jtv) 11351 } 11352 11353 case "programDateTimePeriod": 11354 if value != nil { 11355 jtv, ok := value.(json.Number) 11356 if !ok { 11357 return fmt.Errorf("expected __integerMin0Max3600 to be json.Number, got %T instead", value) 11358 } 11359 i64, err := jtv.Int64() 11360 if err != nil { 11361 return err 11362 } 11363 sv.ProgramDateTimePeriod = int32(i64) 11364 } 11365 11366 case "segmentControl": 11367 if value != nil { 11368 jtv, ok := value.(string) 11369 if !ok { 11370 return fmt.Errorf("expected HlsSegmentControl to be of type string, got %T instead", value) 11371 } 11372 sv.SegmentControl = types.HlsSegmentControl(jtv) 11373 } 11374 11375 case "segmentLength": 11376 if value != nil { 11377 jtv, ok := value.(json.Number) 11378 if !ok { 11379 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 11380 } 11381 i64, err := jtv.Int64() 11382 if err != nil { 11383 return err 11384 } 11385 sv.SegmentLength = int32(i64) 11386 } 11387 11388 case "segmentsPerSubdirectory": 11389 if value != nil { 11390 jtv, ok := value.(json.Number) 11391 if !ok { 11392 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 11393 } 11394 i64, err := jtv.Int64() 11395 if err != nil { 11396 return err 11397 } 11398 sv.SegmentsPerSubdirectory = int32(i64) 11399 } 11400 11401 case "streamInfResolution": 11402 if value != nil { 11403 jtv, ok := value.(string) 11404 if !ok { 11405 return fmt.Errorf("expected HlsStreamInfResolution to be of type string, got %T instead", value) 11406 } 11407 sv.StreamInfResolution = types.HlsStreamInfResolution(jtv) 11408 } 11409 11410 case "timedMetadataId3Frame": 11411 if value != nil { 11412 jtv, ok := value.(string) 11413 if !ok { 11414 return fmt.Errorf("expected HlsTimedMetadataId3Frame to be of type string, got %T instead", value) 11415 } 11416 sv.TimedMetadataId3Frame = types.HlsTimedMetadataId3Frame(jtv) 11417 } 11418 11419 case "timedMetadataId3Period": 11420 if value != nil { 11421 jtv, ok := value.(json.Number) 11422 if !ok { 11423 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 11424 } 11425 i64, err := jtv.Int64() 11426 if err != nil { 11427 return err 11428 } 11429 sv.TimedMetadataId3Period = int32(i64) 11430 } 11431 11432 case "timestampDeltaMilliseconds": 11433 if value != nil { 11434 jtv, ok := value.(json.Number) 11435 if !ok { 11436 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 11437 } 11438 i64, err := jtv.Int64() 11439 if err != nil { 11440 return err 11441 } 11442 sv.TimestampDeltaMilliseconds = int32(i64) 11443 } 11444 11445 default: 11446 _, _ = key, value 11447 11448 } 11449 } 11450 *v = sv 11451 return nil 11452} 11453 11454func awsRestjson1_deserializeDocumentHlsSettings(v **types.HlsSettings, value interface{}) error { 11455 if v == nil { 11456 return fmt.Errorf("unexpected nil of type %T", v) 11457 } 11458 if value == nil { 11459 return nil 11460 } 11461 11462 shape, ok := value.(map[string]interface{}) 11463 if !ok { 11464 return fmt.Errorf("unexpected JSON type %v", value) 11465 } 11466 11467 var sv *types.HlsSettings 11468 if *v == nil { 11469 sv = &types.HlsSettings{} 11470 } else { 11471 sv = *v 11472 } 11473 11474 for key, value := range shape { 11475 switch key { 11476 case "audioGroupId": 11477 if value != nil { 11478 jtv, ok := value.(string) 11479 if !ok { 11480 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11481 } 11482 sv.AudioGroupId = ptr.String(jtv) 11483 } 11484 11485 case "audioOnlyContainer": 11486 if value != nil { 11487 jtv, ok := value.(string) 11488 if !ok { 11489 return fmt.Errorf("expected HlsAudioOnlyContainer to be of type string, got %T instead", value) 11490 } 11491 sv.AudioOnlyContainer = types.HlsAudioOnlyContainer(jtv) 11492 } 11493 11494 case "audioRenditionSets": 11495 if value != nil { 11496 jtv, ok := value.(string) 11497 if !ok { 11498 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11499 } 11500 sv.AudioRenditionSets = ptr.String(jtv) 11501 } 11502 11503 case "audioTrackType": 11504 if value != nil { 11505 jtv, ok := value.(string) 11506 if !ok { 11507 return fmt.Errorf("expected HlsAudioTrackType to be of type string, got %T instead", value) 11508 } 11509 sv.AudioTrackType = types.HlsAudioTrackType(jtv) 11510 } 11511 11512 case "iFrameOnlyManifest": 11513 if value != nil { 11514 jtv, ok := value.(string) 11515 if !ok { 11516 return fmt.Errorf("expected HlsIFrameOnlyManifest to be of type string, got %T instead", value) 11517 } 11518 sv.IFrameOnlyManifest = types.HlsIFrameOnlyManifest(jtv) 11519 } 11520 11521 case "segmentModifier": 11522 if value != nil { 11523 jtv, ok := value.(string) 11524 if !ok { 11525 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11526 } 11527 sv.SegmentModifier = ptr.String(jtv) 11528 } 11529 11530 default: 11531 _, _ = key, value 11532 11533 } 11534 } 11535 *v = sv 11536 return nil 11537} 11538 11539func awsRestjson1_deserializeDocumentHopDestination(v **types.HopDestination, value interface{}) error { 11540 if v == nil { 11541 return fmt.Errorf("unexpected nil of type %T", v) 11542 } 11543 if value == nil { 11544 return nil 11545 } 11546 11547 shape, ok := value.(map[string]interface{}) 11548 if !ok { 11549 return fmt.Errorf("unexpected JSON type %v", value) 11550 } 11551 11552 var sv *types.HopDestination 11553 if *v == nil { 11554 sv = &types.HopDestination{} 11555 } else { 11556 sv = *v 11557 } 11558 11559 for key, value := range shape { 11560 switch key { 11561 case "priority": 11562 if value != nil { 11563 jtv, ok := value.(json.Number) 11564 if !ok { 11565 return fmt.Errorf("expected __integerMinNegative50Max50 to be json.Number, got %T instead", value) 11566 } 11567 i64, err := jtv.Int64() 11568 if err != nil { 11569 return err 11570 } 11571 sv.Priority = int32(i64) 11572 } 11573 11574 case "queue": 11575 if value != nil { 11576 jtv, ok := value.(string) 11577 if !ok { 11578 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 11579 } 11580 sv.Queue = ptr.String(jtv) 11581 } 11582 11583 case "waitMinutes": 11584 if value != nil { 11585 jtv, ok := value.(json.Number) 11586 if !ok { 11587 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 11588 } 11589 i64, err := jtv.Int64() 11590 if err != nil { 11591 return err 11592 } 11593 sv.WaitMinutes = int32(i64) 11594 } 11595 11596 default: 11597 _, _ = key, value 11598 11599 } 11600 } 11601 *v = sv 11602 return nil 11603} 11604 11605func awsRestjson1_deserializeDocumentId3Insertion(v **types.Id3Insertion, value interface{}) error { 11606 if v == nil { 11607 return fmt.Errorf("unexpected nil of type %T", v) 11608 } 11609 if value == nil { 11610 return nil 11611 } 11612 11613 shape, ok := value.(map[string]interface{}) 11614 if !ok { 11615 return fmt.Errorf("unexpected JSON type %v", value) 11616 } 11617 11618 var sv *types.Id3Insertion 11619 if *v == nil { 11620 sv = &types.Id3Insertion{} 11621 } else { 11622 sv = *v 11623 } 11624 11625 for key, value := range shape { 11626 switch key { 11627 case "id3": 11628 if value != nil { 11629 jtv, ok := value.(string) 11630 if !ok { 11631 return fmt.Errorf("expected __stringPatternAZaZ0902 to be of type string, got %T instead", value) 11632 } 11633 sv.Id3 = ptr.String(jtv) 11634 } 11635 11636 case "timecode": 11637 if value != nil { 11638 jtv, ok := value.(string) 11639 if !ok { 11640 return fmt.Errorf("expected __stringPattern010920405090509092 to be of type string, got %T instead", value) 11641 } 11642 sv.Timecode = ptr.String(jtv) 11643 } 11644 11645 default: 11646 _, _ = key, value 11647 11648 } 11649 } 11650 *v = sv 11651 return nil 11652} 11653 11654func awsRestjson1_deserializeDocumentImageInserter(v **types.ImageInserter, value interface{}) error { 11655 if v == nil { 11656 return fmt.Errorf("unexpected nil of type %T", v) 11657 } 11658 if value == nil { 11659 return nil 11660 } 11661 11662 shape, ok := value.(map[string]interface{}) 11663 if !ok { 11664 return fmt.Errorf("unexpected JSON type %v", value) 11665 } 11666 11667 var sv *types.ImageInserter 11668 if *v == nil { 11669 sv = &types.ImageInserter{} 11670 } else { 11671 sv = *v 11672 } 11673 11674 for key, value := range shape { 11675 switch key { 11676 case "insertableImages": 11677 if err := awsRestjson1_deserializeDocument__listOfInsertableImage(&sv.InsertableImages, value); err != nil { 11678 return err 11679 } 11680 11681 default: 11682 _, _ = key, value 11683 11684 } 11685 } 11686 *v = sv 11687 return nil 11688} 11689 11690func awsRestjson1_deserializeDocumentImscDestinationSettings(v **types.ImscDestinationSettings, value interface{}) error { 11691 if v == nil { 11692 return fmt.Errorf("unexpected nil of type %T", v) 11693 } 11694 if value == nil { 11695 return nil 11696 } 11697 11698 shape, ok := value.(map[string]interface{}) 11699 if !ok { 11700 return fmt.Errorf("unexpected JSON type %v", value) 11701 } 11702 11703 var sv *types.ImscDestinationSettings 11704 if *v == nil { 11705 sv = &types.ImscDestinationSettings{} 11706 } else { 11707 sv = *v 11708 } 11709 11710 for key, value := range shape { 11711 switch key { 11712 case "stylePassthrough": 11713 if value != nil { 11714 jtv, ok := value.(string) 11715 if !ok { 11716 return fmt.Errorf("expected ImscStylePassthrough to be of type string, got %T instead", value) 11717 } 11718 sv.StylePassthrough = types.ImscStylePassthrough(jtv) 11719 } 11720 11721 default: 11722 _, _ = key, value 11723 11724 } 11725 } 11726 *v = sv 11727 return nil 11728} 11729 11730func awsRestjson1_deserializeDocumentInput(v **types.Input, value interface{}) error { 11731 if v == nil { 11732 return fmt.Errorf("unexpected nil of type %T", v) 11733 } 11734 if value == nil { 11735 return nil 11736 } 11737 11738 shape, ok := value.(map[string]interface{}) 11739 if !ok { 11740 return fmt.Errorf("unexpected JSON type %v", value) 11741 } 11742 11743 var sv *types.Input 11744 if *v == nil { 11745 sv = &types.Input{} 11746 } else { 11747 sv = *v 11748 } 11749 11750 for key, value := range shape { 11751 switch key { 11752 case "audioSelectorGroups": 11753 if err := awsRestjson1_deserializeDocument__mapOfAudioSelectorGroup(&sv.AudioSelectorGroups, value); err != nil { 11754 return err 11755 } 11756 11757 case "audioSelectors": 11758 if err := awsRestjson1_deserializeDocument__mapOfAudioSelector(&sv.AudioSelectors, value); err != nil { 11759 return err 11760 } 11761 11762 case "captionSelectors": 11763 if err := awsRestjson1_deserializeDocument__mapOfCaptionSelector(&sv.CaptionSelectors, value); err != nil { 11764 return err 11765 } 11766 11767 case "crop": 11768 if err := awsRestjson1_deserializeDocumentRectangle(&sv.Crop, value); err != nil { 11769 return err 11770 } 11771 11772 case "deblockFilter": 11773 if value != nil { 11774 jtv, ok := value.(string) 11775 if !ok { 11776 return fmt.Errorf("expected InputDeblockFilter to be of type string, got %T instead", value) 11777 } 11778 sv.DeblockFilter = types.InputDeblockFilter(jtv) 11779 } 11780 11781 case "decryptionSettings": 11782 if err := awsRestjson1_deserializeDocumentInputDecryptionSettings(&sv.DecryptionSettings, value); err != nil { 11783 return err 11784 } 11785 11786 case "denoiseFilter": 11787 if value != nil { 11788 jtv, ok := value.(string) 11789 if !ok { 11790 return fmt.Errorf("expected InputDenoiseFilter to be of type string, got %T instead", value) 11791 } 11792 sv.DenoiseFilter = types.InputDenoiseFilter(jtv) 11793 } 11794 11795 case "fileInput": 11796 if value != nil { 11797 jtv, ok := value.(string) 11798 if !ok { 11799 return fmt.Errorf("expected __stringPatternS3MM2PPMM2VVMMPPEEGGMMPP3AAVVIIMMPP4FFLLVVMMPPTTMMPPGGMM4VVTTRRPPFF4VVMM2TTSSTTSS264HH264MMKKVVMMKKAAMMOOVVMMTTSSMM2TTWWMMVVAASSFFVVOOBB3GGPP3GGPPPPMMXXFFDDIIVVXXXXVVIIDDRRAAWWDDVVGGXXFFMM1VV3GG2VVMMFFMM3UU8WWEEBBMMLLCCHHGGXXFFMMPPEEGG2MMXXFFMMPPEEGG2MMXXFFHHDDWWAAVVYY4MMXXMMLLOOGGGGaAHttpsMM2VVMMPPEEGGMMPP3AAVVIIMMPP4FFLLVVMMPPTTMMPPGGMM4VVTTRRPPFF4VVMM2TTSSTTSS264HH264MMKKVVMMKKAAMMOOVVMMTTSSMM2TTWWMMVVAASSFFVVOOBB3GGPP3GGPPPPMMXXFFDDIIVVXXXXVVIIDDRRAAWWDDVVGGXXFFMM1VV3GG2VVMMFFMM3UU8WWEEBBMMLLCCHHGGXXFFMMPPEEGG2MMXXFFMMPPEEGG2MMXXFFHHDDWWAAVVYY4MMXXMMLLOOGGGGaA to be of type string, got %T instead", value) 11800 } 11801 sv.FileInput = ptr.String(jtv) 11802 } 11803 11804 case "filterEnable": 11805 if value != nil { 11806 jtv, ok := value.(string) 11807 if !ok { 11808 return fmt.Errorf("expected InputFilterEnable to be of type string, got %T instead", value) 11809 } 11810 sv.FilterEnable = types.InputFilterEnable(jtv) 11811 } 11812 11813 case "filterStrength": 11814 if value != nil { 11815 jtv, ok := value.(json.Number) 11816 if !ok { 11817 return fmt.Errorf("expected __integerMinNegative5Max5 to be json.Number, got %T instead", value) 11818 } 11819 i64, err := jtv.Int64() 11820 if err != nil { 11821 return err 11822 } 11823 sv.FilterStrength = int32(i64) 11824 } 11825 11826 case "imageInserter": 11827 if err := awsRestjson1_deserializeDocumentImageInserter(&sv.ImageInserter, value); err != nil { 11828 return err 11829 } 11830 11831 case "inputClippings": 11832 if err := awsRestjson1_deserializeDocument__listOfInputClipping(&sv.InputClippings, value); err != nil { 11833 return err 11834 } 11835 11836 case "inputScanType": 11837 if value != nil { 11838 jtv, ok := value.(string) 11839 if !ok { 11840 return fmt.Errorf("expected InputScanType to be of type string, got %T instead", value) 11841 } 11842 sv.InputScanType = types.InputScanType(jtv) 11843 } 11844 11845 case "position": 11846 if err := awsRestjson1_deserializeDocumentRectangle(&sv.Position, value); err != nil { 11847 return err 11848 } 11849 11850 case "programNumber": 11851 if value != nil { 11852 jtv, ok := value.(json.Number) 11853 if !ok { 11854 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 11855 } 11856 i64, err := jtv.Int64() 11857 if err != nil { 11858 return err 11859 } 11860 sv.ProgramNumber = int32(i64) 11861 } 11862 11863 case "psiControl": 11864 if value != nil { 11865 jtv, ok := value.(string) 11866 if !ok { 11867 return fmt.Errorf("expected InputPsiControl to be of type string, got %T instead", value) 11868 } 11869 sv.PsiControl = types.InputPsiControl(jtv) 11870 } 11871 11872 case "supplementalImps": 11873 if err := awsRestjson1_deserializeDocument__listOf__stringPatternS3ASSETMAPXml(&sv.SupplementalImps, value); err != nil { 11874 return err 11875 } 11876 11877 case "timecodeSource": 11878 if value != nil { 11879 jtv, ok := value.(string) 11880 if !ok { 11881 return fmt.Errorf("expected InputTimecodeSource to be of type string, got %T instead", value) 11882 } 11883 sv.TimecodeSource = types.InputTimecodeSource(jtv) 11884 } 11885 11886 case "timecodeStart": 11887 if value != nil { 11888 jtv, ok := value.(string) 11889 if !ok { 11890 return fmt.Errorf("expected __stringMin11Max11Pattern01D20305D205D to be of type string, got %T instead", value) 11891 } 11892 sv.TimecodeStart = ptr.String(jtv) 11893 } 11894 11895 case "videoSelector": 11896 if err := awsRestjson1_deserializeDocumentVideoSelector(&sv.VideoSelector, value); err != nil { 11897 return err 11898 } 11899 11900 default: 11901 _, _ = key, value 11902 11903 } 11904 } 11905 *v = sv 11906 return nil 11907} 11908 11909func awsRestjson1_deserializeDocumentInputClipping(v **types.InputClipping, value interface{}) error { 11910 if v == nil { 11911 return fmt.Errorf("unexpected nil of type %T", v) 11912 } 11913 if value == nil { 11914 return nil 11915 } 11916 11917 shape, ok := value.(map[string]interface{}) 11918 if !ok { 11919 return fmt.Errorf("unexpected JSON type %v", value) 11920 } 11921 11922 var sv *types.InputClipping 11923 if *v == nil { 11924 sv = &types.InputClipping{} 11925 } else { 11926 sv = *v 11927 } 11928 11929 for key, value := range shape { 11930 switch key { 11931 case "endTimecode": 11932 if value != nil { 11933 jtv, ok := value.(string) 11934 if !ok { 11935 return fmt.Errorf("expected __stringPattern010920405090509092 to be of type string, got %T instead", value) 11936 } 11937 sv.EndTimecode = ptr.String(jtv) 11938 } 11939 11940 case "startTimecode": 11941 if value != nil { 11942 jtv, ok := value.(string) 11943 if !ok { 11944 return fmt.Errorf("expected __stringPattern010920405090509092 to be of type string, got %T instead", value) 11945 } 11946 sv.StartTimecode = ptr.String(jtv) 11947 } 11948 11949 default: 11950 _, _ = key, value 11951 11952 } 11953 } 11954 *v = sv 11955 return nil 11956} 11957 11958func awsRestjson1_deserializeDocumentInputDecryptionSettings(v **types.InputDecryptionSettings, value interface{}) error { 11959 if v == nil { 11960 return fmt.Errorf("unexpected nil of type %T", v) 11961 } 11962 if value == nil { 11963 return nil 11964 } 11965 11966 shape, ok := value.(map[string]interface{}) 11967 if !ok { 11968 return fmt.Errorf("unexpected JSON type %v", value) 11969 } 11970 11971 var sv *types.InputDecryptionSettings 11972 if *v == nil { 11973 sv = &types.InputDecryptionSettings{} 11974 } else { 11975 sv = *v 11976 } 11977 11978 for key, value := range shape { 11979 switch key { 11980 case "decryptionMode": 11981 if value != nil { 11982 jtv, ok := value.(string) 11983 if !ok { 11984 return fmt.Errorf("expected DecryptionMode to be of type string, got %T instead", value) 11985 } 11986 sv.DecryptionMode = types.DecryptionMode(jtv) 11987 } 11988 11989 case "encryptedDecryptionKey": 11990 if value != nil { 11991 jtv, ok := value.(string) 11992 if !ok { 11993 return fmt.Errorf("expected __stringMin24Max512PatternAZaZ0902 to be of type string, got %T instead", value) 11994 } 11995 sv.EncryptedDecryptionKey = ptr.String(jtv) 11996 } 11997 11998 case "initializationVector": 11999 if value != nil { 12000 jtv, ok := value.(string) 12001 if !ok { 12002 return fmt.Errorf("expected __stringMin16Max24PatternAZaZ0922AZaZ0916 to be of type string, got %T instead", value) 12003 } 12004 sv.InitializationVector = ptr.String(jtv) 12005 } 12006 12007 case "kmsKeyRegion": 12008 if value != nil { 12009 jtv, ok := value.(string) 12010 if !ok { 12011 return fmt.Errorf("expected __stringMin9Max19PatternAZ26EastWestCentralNorthSouthEastWest1912 to be of type string, got %T instead", value) 12012 } 12013 sv.KmsKeyRegion = ptr.String(jtv) 12014 } 12015 12016 default: 12017 _, _ = key, value 12018 12019 } 12020 } 12021 *v = sv 12022 return nil 12023} 12024 12025func awsRestjson1_deserializeDocumentInputTemplate(v **types.InputTemplate, value interface{}) error { 12026 if v == nil { 12027 return fmt.Errorf("unexpected nil of type %T", v) 12028 } 12029 if value == nil { 12030 return nil 12031 } 12032 12033 shape, ok := value.(map[string]interface{}) 12034 if !ok { 12035 return fmt.Errorf("unexpected JSON type %v", value) 12036 } 12037 12038 var sv *types.InputTemplate 12039 if *v == nil { 12040 sv = &types.InputTemplate{} 12041 } else { 12042 sv = *v 12043 } 12044 12045 for key, value := range shape { 12046 switch key { 12047 case "audioSelectorGroups": 12048 if err := awsRestjson1_deserializeDocument__mapOfAudioSelectorGroup(&sv.AudioSelectorGroups, value); err != nil { 12049 return err 12050 } 12051 12052 case "audioSelectors": 12053 if err := awsRestjson1_deserializeDocument__mapOfAudioSelector(&sv.AudioSelectors, value); err != nil { 12054 return err 12055 } 12056 12057 case "captionSelectors": 12058 if err := awsRestjson1_deserializeDocument__mapOfCaptionSelector(&sv.CaptionSelectors, value); err != nil { 12059 return err 12060 } 12061 12062 case "crop": 12063 if err := awsRestjson1_deserializeDocumentRectangle(&sv.Crop, value); err != nil { 12064 return err 12065 } 12066 12067 case "deblockFilter": 12068 if value != nil { 12069 jtv, ok := value.(string) 12070 if !ok { 12071 return fmt.Errorf("expected InputDeblockFilter to be of type string, got %T instead", value) 12072 } 12073 sv.DeblockFilter = types.InputDeblockFilter(jtv) 12074 } 12075 12076 case "denoiseFilter": 12077 if value != nil { 12078 jtv, ok := value.(string) 12079 if !ok { 12080 return fmt.Errorf("expected InputDenoiseFilter to be of type string, got %T instead", value) 12081 } 12082 sv.DenoiseFilter = types.InputDenoiseFilter(jtv) 12083 } 12084 12085 case "filterEnable": 12086 if value != nil { 12087 jtv, ok := value.(string) 12088 if !ok { 12089 return fmt.Errorf("expected InputFilterEnable to be of type string, got %T instead", value) 12090 } 12091 sv.FilterEnable = types.InputFilterEnable(jtv) 12092 } 12093 12094 case "filterStrength": 12095 if value != nil { 12096 jtv, ok := value.(json.Number) 12097 if !ok { 12098 return fmt.Errorf("expected __integerMinNegative5Max5 to be json.Number, got %T instead", value) 12099 } 12100 i64, err := jtv.Int64() 12101 if err != nil { 12102 return err 12103 } 12104 sv.FilterStrength = int32(i64) 12105 } 12106 12107 case "imageInserter": 12108 if err := awsRestjson1_deserializeDocumentImageInserter(&sv.ImageInserter, value); err != nil { 12109 return err 12110 } 12111 12112 case "inputClippings": 12113 if err := awsRestjson1_deserializeDocument__listOfInputClipping(&sv.InputClippings, value); err != nil { 12114 return err 12115 } 12116 12117 case "inputScanType": 12118 if value != nil { 12119 jtv, ok := value.(string) 12120 if !ok { 12121 return fmt.Errorf("expected InputScanType to be of type string, got %T instead", value) 12122 } 12123 sv.InputScanType = types.InputScanType(jtv) 12124 } 12125 12126 case "position": 12127 if err := awsRestjson1_deserializeDocumentRectangle(&sv.Position, value); err != nil { 12128 return err 12129 } 12130 12131 case "programNumber": 12132 if value != nil { 12133 jtv, ok := value.(json.Number) 12134 if !ok { 12135 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 12136 } 12137 i64, err := jtv.Int64() 12138 if err != nil { 12139 return err 12140 } 12141 sv.ProgramNumber = int32(i64) 12142 } 12143 12144 case "psiControl": 12145 if value != nil { 12146 jtv, ok := value.(string) 12147 if !ok { 12148 return fmt.Errorf("expected InputPsiControl to be of type string, got %T instead", value) 12149 } 12150 sv.PsiControl = types.InputPsiControl(jtv) 12151 } 12152 12153 case "timecodeSource": 12154 if value != nil { 12155 jtv, ok := value.(string) 12156 if !ok { 12157 return fmt.Errorf("expected InputTimecodeSource to be of type string, got %T instead", value) 12158 } 12159 sv.TimecodeSource = types.InputTimecodeSource(jtv) 12160 } 12161 12162 case "timecodeStart": 12163 if value != nil { 12164 jtv, ok := value.(string) 12165 if !ok { 12166 return fmt.Errorf("expected __stringMin11Max11Pattern01D20305D205D to be of type string, got %T instead", value) 12167 } 12168 sv.TimecodeStart = ptr.String(jtv) 12169 } 12170 12171 case "videoSelector": 12172 if err := awsRestjson1_deserializeDocumentVideoSelector(&sv.VideoSelector, value); err != nil { 12173 return err 12174 } 12175 12176 default: 12177 _, _ = key, value 12178 12179 } 12180 } 12181 *v = sv 12182 return nil 12183} 12184 12185func awsRestjson1_deserializeDocumentInsertableImage(v **types.InsertableImage, value interface{}) error { 12186 if v == nil { 12187 return fmt.Errorf("unexpected nil of type %T", v) 12188 } 12189 if value == nil { 12190 return nil 12191 } 12192 12193 shape, ok := value.(map[string]interface{}) 12194 if !ok { 12195 return fmt.Errorf("unexpected JSON type %v", value) 12196 } 12197 12198 var sv *types.InsertableImage 12199 if *v == nil { 12200 sv = &types.InsertableImage{} 12201 } else { 12202 sv = *v 12203 } 12204 12205 for key, value := range shape { 12206 switch key { 12207 case "duration": 12208 if value != nil { 12209 jtv, ok := value.(json.Number) 12210 if !ok { 12211 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 12212 } 12213 i64, err := jtv.Int64() 12214 if err != nil { 12215 return err 12216 } 12217 sv.Duration = int32(i64) 12218 } 12219 12220 case "fadeIn": 12221 if value != nil { 12222 jtv, ok := value.(json.Number) 12223 if !ok { 12224 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 12225 } 12226 i64, err := jtv.Int64() 12227 if err != nil { 12228 return err 12229 } 12230 sv.FadeIn = int32(i64) 12231 } 12232 12233 case "fadeOut": 12234 if value != nil { 12235 jtv, ok := value.(json.Number) 12236 if !ok { 12237 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 12238 } 12239 i64, err := jtv.Int64() 12240 if err != nil { 12241 return err 12242 } 12243 sv.FadeOut = int32(i64) 12244 } 12245 12246 case "height": 12247 if value != nil { 12248 jtv, ok := value.(json.Number) 12249 if !ok { 12250 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 12251 } 12252 i64, err := jtv.Int64() 12253 if err != nil { 12254 return err 12255 } 12256 sv.Height = int32(i64) 12257 } 12258 12259 case "imageInserterInput": 12260 if value != nil { 12261 jtv, ok := value.(string) 12262 if !ok { 12263 return fmt.Errorf("expected __stringMin14PatternS3BmpBMPPngPNGTgaTGAHttpsBmpBMPPngPNGTgaTGA to be of type string, got %T instead", value) 12264 } 12265 sv.ImageInserterInput = ptr.String(jtv) 12266 } 12267 12268 case "imageX": 12269 if value != nil { 12270 jtv, ok := value.(json.Number) 12271 if !ok { 12272 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 12273 } 12274 i64, err := jtv.Int64() 12275 if err != nil { 12276 return err 12277 } 12278 sv.ImageX = int32(i64) 12279 } 12280 12281 case "imageY": 12282 if value != nil { 12283 jtv, ok := value.(json.Number) 12284 if !ok { 12285 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 12286 } 12287 i64, err := jtv.Int64() 12288 if err != nil { 12289 return err 12290 } 12291 sv.ImageY = int32(i64) 12292 } 12293 12294 case "layer": 12295 if value != nil { 12296 jtv, ok := value.(json.Number) 12297 if !ok { 12298 return fmt.Errorf("expected __integerMin0Max99 to be json.Number, got %T instead", value) 12299 } 12300 i64, err := jtv.Int64() 12301 if err != nil { 12302 return err 12303 } 12304 sv.Layer = int32(i64) 12305 } 12306 12307 case "opacity": 12308 if value != nil { 12309 jtv, ok := value.(json.Number) 12310 if !ok { 12311 return fmt.Errorf("expected __integerMin0Max100 to be json.Number, got %T instead", value) 12312 } 12313 i64, err := jtv.Int64() 12314 if err != nil { 12315 return err 12316 } 12317 sv.Opacity = int32(i64) 12318 } 12319 12320 case "startTime": 12321 if value != nil { 12322 jtv, ok := value.(string) 12323 if !ok { 12324 return fmt.Errorf("expected __stringPattern01D20305D205D to be of type string, got %T instead", value) 12325 } 12326 sv.StartTime = ptr.String(jtv) 12327 } 12328 12329 case "width": 12330 if value != nil { 12331 jtv, ok := value.(json.Number) 12332 if !ok { 12333 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 12334 } 12335 i64, err := jtv.Int64() 12336 if err != nil { 12337 return err 12338 } 12339 sv.Width = int32(i64) 12340 } 12341 12342 default: 12343 _, _ = key, value 12344 12345 } 12346 } 12347 *v = sv 12348 return nil 12349} 12350 12351func awsRestjson1_deserializeDocumentInternalServerErrorException(v **types.InternalServerErrorException, value interface{}) error { 12352 if v == nil { 12353 return fmt.Errorf("unexpected nil of type %T", v) 12354 } 12355 if value == nil { 12356 return nil 12357 } 12358 12359 shape, ok := value.(map[string]interface{}) 12360 if !ok { 12361 return fmt.Errorf("unexpected JSON type %v", value) 12362 } 12363 12364 var sv *types.InternalServerErrorException 12365 if *v == nil { 12366 sv = &types.InternalServerErrorException{} 12367 } else { 12368 sv = *v 12369 } 12370 12371 for key, value := range shape { 12372 switch key { 12373 case "message": 12374 if value != nil { 12375 jtv, ok := value.(string) 12376 if !ok { 12377 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12378 } 12379 sv.Message = ptr.String(jtv) 12380 } 12381 12382 default: 12383 _, _ = key, value 12384 12385 } 12386 } 12387 *v = sv 12388 return nil 12389} 12390 12391func awsRestjson1_deserializeDocumentJob(v **types.Job, value interface{}) error { 12392 if v == nil { 12393 return fmt.Errorf("unexpected nil of type %T", v) 12394 } 12395 if value == nil { 12396 return nil 12397 } 12398 12399 shape, ok := value.(map[string]interface{}) 12400 if !ok { 12401 return fmt.Errorf("unexpected JSON type %v", value) 12402 } 12403 12404 var sv *types.Job 12405 if *v == nil { 12406 sv = &types.Job{} 12407 } else { 12408 sv = *v 12409 } 12410 12411 for key, value := range shape { 12412 switch key { 12413 case "accelerationSettings": 12414 if err := awsRestjson1_deserializeDocumentAccelerationSettings(&sv.AccelerationSettings, value); err != nil { 12415 return err 12416 } 12417 12418 case "accelerationStatus": 12419 if value != nil { 12420 jtv, ok := value.(string) 12421 if !ok { 12422 return fmt.Errorf("expected AccelerationStatus to be of type string, got %T instead", value) 12423 } 12424 sv.AccelerationStatus = types.AccelerationStatus(jtv) 12425 } 12426 12427 case "arn": 12428 if value != nil { 12429 jtv, ok := value.(string) 12430 if !ok { 12431 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12432 } 12433 sv.Arn = ptr.String(jtv) 12434 } 12435 12436 case "billingTagsSource": 12437 if value != nil { 12438 jtv, ok := value.(string) 12439 if !ok { 12440 return fmt.Errorf("expected BillingTagsSource to be of type string, got %T instead", value) 12441 } 12442 sv.BillingTagsSource = types.BillingTagsSource(jtv) 12443 } 12444 12445 case "createdAt": 12446 if value != nil { 12447 jtv, ok := value.(json.Number) 12448 if !ok { 12449 return fmt.Errorf("expected __timestampUnix to be json.Number, got %T instead", value) 12450 } 12451 f64, err := jtv.Float64() 12452 if err != nil { 12453 return err 12454 } 12455 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12456 } 12457 12458 case "currentPhase": 12459 if value != nil { 12460 jtv, ok := value.(string) 12461 if !ok { 12462 return fmt.Errorf("expected JobPhase to be of type string, got %T instead", value) 12463 } 12464 sv.CurrentPhase = types.JobPhase(jtv) 12465 } 12466 12467 case "errorCode": 12468 if value != nil { 12469 jtv, ok := value.(json.Number) 12470 if !ok { 12471 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 12472 } 12473 i64, err := jtv.Int64() 12474 if err != nil { 12475 return err 12476 } 12477 sv.ErrorCode = int32(i64) 12478 } 12479 12480 case "errorMessage": 12481 if value != nil { 12482 jtv, ok := value.(string) 12483 if !ok { 12484 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12485 } 12486 sv.ErrorMessage = ptr.String(jtv) 12487 } 12488 12489 case "hopDestinations": 12490 if err := awsRestjson1_deserializeDocument__listOfHopDestination(&sv.HopDestinations, value); err != nil { 12491 return err 12492 } 12493 12494 case "id": 12495 if value != nil { 12496 jtv, ok := value.(string) 12497 if !ok { 12498 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12499 } 12500 sv.Id = ptr.String(jtv) 12501 } 12502 12503 case "jobPercentComplete": 12504 if value != nil { 12505 jtv, ok := value.(json.Number) 12506 if !ok { 12507 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 12508 } 12509 i64, err := jtv.Int64() 12510 if err != nil { 12511 return err 12512 } 12513 sv.JobPercentComplete = int32(i64) 12514 } 12515 12516 case "jobTemplate": 12517 if value != nil { 12518 jtv, ok := value.(string) 12519 if !ok { 12520 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12521 } 12522 sv.JobTemplate = ptr.String(jtv) 12523 } 12524 12525 case "messages": 12526 if err := awsRestjson1_deserializeDocumentJobMessages(&sv.Messages, value); err != nil { 12527 return err 12528 } 12529 12530 case "outputGroupDetails": 12531 if err := awsRestjson1_deserializeDocument__listOfOutputGroupDetail(&sv.OutputGroupDetails, value); err != nil { 12532 return err 12533 } 12534 12535 case "priority": 12536 if value != nil { 12537 jtv, ok := value.(json.Number) 12538 if !ok { 12539 return fmt.Errorf("expected __integerMinNegative50Max50 to be json.Number, got %T instead", value) 12540 } 12541 i64, err := jtv.Int64() 12542 if err != nil { 12543 return err 12544 } 12545 sv.Priority = int32(i64) 12546 } 12547 12548 case "queue": 12549 if value != nil { 12550 jtv, ok := value.(string) 12551 if !ok { 12552 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12553 } 12554 sv.Queue = ptr.String(jtv) 12555 } 12556 12557 case "queueTransitions": 12558 if err := awsRestjson1_deserializeDocument__listOfQueueTransition(&sv.QueueTransitions, value); err != nil { 12559 return err 12560 } 12561 12562 case "retryCount": 12563 if value != nil { 12564 jtv, ok := value.(json.Number) 12565 if !ok { 12566 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 12567 } 12568 i64, err := jtv.Int64() 12569 if err != nil { 12570 return err 12571 } 12572 sv.RetryCount = int32(i64) 12573 } 12574 12575 case "role": 12576 if value != nil { 12577 jtv, ok := value.(string) 12578 if !ok { 12579 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12580 } 12581 sv.Role = ptr.String(jtv) 12582 } 12583 12584 case "settings": 12585 if err := awsRestjson1_deserializeDocumentJobSettings(&sv.Settings, value); err != nil { 12586 return err 12587 } 12588 12589 case "simulateReservedQueue": 12590 if value != nil { 12591 jtv, ok := value.(string) 12592 if !ok { 12593 return fmt.Errorf("expected SimulateReservedQueue to be of type string, got %T instead", value) 12594 } 12595 sv.SimulateReservedQueue = types.SimulateReservedQueue(jtv) 12596 } 12597 12598 case "status": 12599 if value != nil { 12600 jtv, ok := value.(string) 12601 if !ok { 12602 return fmt.Errorf("expected JobStatus to be of type string, got %T instead", value) 12603 } 12604 sv.Status = types.JobStatus(jtv) 12605 } 12606 12607 case "statusUpdateInterval": 12608 if value != nil { 12609 jtv, ok := value.(string) 12610 if !ok { 12611 return fmt.Errorf("expected StatusUpdateInterval to be of type string, got %T instead", value) 12612 } 12613 sv.StatusUpdateInterval = types.StatusUpdateInterval(jtv) 12614 } 12615 12616 case "timing": 12617 if err := awsRestjson1_deserializeDocumentTiming(&sv.Timing, value); err != nil { 12618 return err 12619 } 12620 12621 case "userMetadata": 12622 if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.UserMetadata, value); err != nil { 12623 return err 12624 } 12625 12626 default: 12627 _, _ = key, value 12628 12629 } 12630 } 12631 *v = sv 12632 return nil 12633} 12634 12635func awsRestjson1_deserializeDocumentJobMessages(v **types.JobMessages, value interface{}) error { 12636 if v == nil { 12637 return fmt.Errorf("unexpected nil of type %T", v) 12638 } 12639 if value == nil { 12640 return nil 12641 } 12642 12643 shape, ok := value.(map[string]interface{}) 12644 if !ok { 12645 return fmt.Errorf("unexpected JSON type %v", value) 12646 } 12647 12648 var sv *types.JobMessages 12649 if *v == nil { 12650 sv = &types.JobMessages{} 12651 } else { 12652 sv = *v 12653 } 12654 12655 for key, value := range shape { 12656 switch key { 12657 case "info": 12658 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.Info, value); err != nil { 12659 return err 12660 } 12661 12662 case "warning": 12663 if err := awsRestjson1_deserializeDocument__listOf__string(&sv.Warning, value); err != nil { 12664 return err 12665 } 12666 12667 default: 12668 _, _ = key, value 12669 12670 } 12671 } 12672 *v = sv 12673 return nil 12674} 12675 12676func awsRestjson1_deserializeDocumentJobSettings(v **types.JobSettings, value interface{}) error { 12677 if v == nil { 12678 return fmt.Errorf("unexpected nil of type %T", v) 12679 } 12680 if value == nil { 12681 return nil 12682 } 12683 12684 shape, ok := value.(map[string]interface{}) 12685 if !ok { 12686 return fmt.Errorf("unexpected JSON type %v", value) 12687 } 12688 12689 var sv *types.JobSettings 12690 if *v == nil { 12691 sv = &types.JobSettings{} 12692 } else { 12693 sv = *v 12694 } 12695 12696 for key, value := range shape { 12697 switch key { 12698 case "adAvailOffset": 12699 if value != nil { 12700 jtv, ok := value.(json.Number) 12701 if !ok { 12702 return fmt.Errorf("expected __integerMinNegative1000Max1000 to be json.Number, got %T instead", value) 12703 } 12704 i64, err := jtv.Int64() 12705 if err != nil { 12706 return err 12707 } 12708 sv.AdAvailOffset = int32(i64) 12709 } 12710 12711 case "availBlanking": 12712 if err := awsRestjson1_deserializeDocumentAvailBlanking(&sv.AvailBlanking, value); err != nil { 12713 return err 12714 } 12715 12716 case "esam": 12717 if err := awsRestjson1_deserializeDocumentEsamSettings(&sv.Esam, value); err != nil { 12718 return err 12719 } 12720 12721 case "inputs": 12722 if err := awsRestjson1_deserializeDocument__listOfInput(&sv.Inputs, value); err != nil { 12723 return err 12724 } 12725 12726 case "motionImageInserter": 12727 if err := awsRestjson1_deserializeDocumentMotionImageInserter(&sv.MotionImageInserter, value); err != nil { 12728 return err 12729 } 12730 12731 case "nielsenConfiguration": 12732 if err := awsRestjson1_deserializeDocumentNielsenConfiguration(&sv.NielsenConfiguration, value); err != nil { 12733 return err 12734 } 12735 12736 case "nielsenNonLinearWatermark": 12737 if err := awsRestjson1_deserializeDocumentNielsenNonLinearWatermarkSettings(&sv.NielsenNonLinearWatermark, value); err != nil { 12738 return err 12739 } 12740 12741 case "outputGroups": 12742 if err := awsRestjson1_deserializeDocument__listOfOutputGroup(&sv.OutputGroups, value); err != nil { 12743 return err 12744 } 12745 12746 case "timecodeConfig": 12747 if err := awsRestjson1_deserializeDocumentTimecodeConfig(&sv.TimecodeConfig, value); err != nil { 12748 return err 12749 } 12750 12751 case "timedMetadataInsertion": 12752 if err := awsRestjson1_deserializeDocumentTimedMetadataInsertion(&sv.TimedMetadataInsertion, value); err != nil { 12753 return err 12754 } 12755 12756 default: 12757 _, _ = key, value 12758 12759 } 12760 } 12761 *v = sv 12762 return nil 12763} 12764 12765func awsRestjson1_deserializeDocumentJobTemplate(v **types.JobTemplate, value interface{}) error { 12766 if v == nil { 12767 return fmt.Errorf("unexpected nil of type %T", v) 12768 } 12769 if value == nil { 12770 return nil 12771 } 12772 12773 shape, ok := value.(map[string]interface{}) 12774 if !ok { 12775 return fmt.Errorf("unexpected JSON type %v", value) 12776 } 12777 12778 var sv *types.JobTemplate 12779 if *v == nil { 12780 sv = &types.JobTemplate{} 12781 } else { 12782 sv = *v 12783 } 12784 12785 for key, value := range shape { 12786 switch key { 12787 case "accelerationSettings": 12788 if err := awsRestjson1_deserializeDocumentAccelerationSettings(&sv.AccelerationSettings, value); err != nil { 12789 return err 12790 } 12791 12792 case "arn": 12793 if value != nil { 12794 jtv, ok := value.(string) 12795 if !ok { 12796 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12797 } 12798 sv.Arn = ptr.String(jtv) 12799 } 12800 12801 case "category": 12802 if value != nil { 12803 jtv, ok := value.(string) 12804 if !ok { 12805 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12806 } 12807 sv.Category = ptr.String(jtv) 12808 } 12809 12810 case "createdAt": 12811 if value != nil { 12812 jtv, ok := value.(json.Number) 12813 if !ok { 12814 return fmt.Errorf("expected __timestampUnix to be json.Number, got %T instead", value) 12815 } 12816 f64, err := jtv.Float64() 12817 if err != nil { 12818 return err 12819 } 12820 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12821 } 12822 12823 case "description": 12824 if value != nil { 12825 jtv, ok := value.(string) 12826 if !ok { 12827 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12828 } 12829 sv.Description = ptr.String(jtv) 12830 } 12831 12832 case "hopDestinations": 12833 if err := awsRestjson1_deserializeDocument__listOfHopDestination(&sv.HopDestinations, value); err != nil { 12834 return err 12835 } 12836 12837 case "lastUpdated": 12838 if value != nil { 12839 jtv, ok := value.(json.Number) 12840 if !ok { 12841 return fmt.Errorf("expected __timestampUnix to be json.Number, got %T instead", value) 12842 } 12843 f64, err := jtv.Float64() 12844 if err != nil { 12845 return err 12846 } 12847 sv.LastUpdated = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12848 } 12849 12850 case "name": 12851 if value != nil { 12852 jtv, ok := value.(string) 12853 if !ok { 12854 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12855 } 12856 sv.Name = ptr.String(jtv) 12857 } 12858 12859 case "priority": 12860 if value != nil { 12861 jtv, ok := value.(json.Number) 12862 if !ok { 12863 return fmt.Errorf("expected __integerMinNegative50Max50 to be json.Number, got %T instead", value) 12864 } 12865 i64, err := jtv.Int64() 12866 if err != nil { 12867 return err 12868 } 12869 sv.Priority = int32(i64) 12870 } 12871 12872 case "queue": 12873 if value != nil { 12874 jtv, ok := value.(string) 12875 if !ok { 12876 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 12877 } 12878 sv.Queue = ptr.String(jtv) 12879 } 12880 12881 case "settings": 12882 if err := awsRestjson1_deserializeDocumentJobTemplateSettings(&sv.Settings, value); err != nil { 12883 return err 12884 } 12885 12886 case "statusUpdateInterval": 12887 if value != nil { 12888 jtv, ok := value.(string) 12889 if !ok { 12890 return fmt.Errorf("expected StatusUpdateInterval to be of type string, got %T instead", value) 12891 } 12892 sv.StatusUpdateInterval = types.StatusUpdateInterval(jtv) 12893 } 12894 12895 case "type": 12896 if value != nil { 12897 jtv, ok := value.(string) 12898 if !ok { 12899 return fmt.Errorf("expected Type to be of type string, got %T instead", value) 12900 } 12901 sv.Type = types.Type(jtv) 12902 } 12903 12904 default: 12905 _, _ = key, value 12906 12907 } 12908 } 12909 *v = sv 12910 return nil 12911} 12912 12913func awsRestjson1_deserializeDocumentJobTemplateSettings(v **types.JobTemplateSettings, 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.JobTemplateSettings 12927 if *v == nil { 12928 sv = &types.JobTemplateSettings{} 12929 } else { 12930 sv = *v 12931 } 12932 12933 for key, value := range shape { 12934 switch key { 12935 case "adAvailOffset": 12936 if value != nil { 12937 jtv, ok := value.(json.Number) 12938 if !ok { 12939 return fmt.Errorf("expected __integerMinNegative1000Max1000 to be json.Number, got %T instead", value) 12940 } 12941 i64, err := jtv.Int64() 12942 if err != nil { 12943 return err 12944 } 12945 sv.AdAvailOffset = int32(i64) 12946 } 12947 12948 case "availBlanking": 12949 if err := awsRestjson1_deserializeDocumentAvailBlanking(&sv.AvailBlanking, value); err != nil { 12950 return err 12951 } 12952 12953 case "esam": 12954 if err := awsRestjson1_deserializeDocumentEsamSettings(&sv.Esam, value); err != nil { 12955 return err 12956 } 12957 12958 case "inputs": 12959 if err := awsRestjson1_deserializeDocument__listOfInputTemplate(&sv.Inputs, value); err != nil { 12960 return err 12961 } 12962 12963 case "motionImageInserter": 12964 if err := awsRestjson1_deserializeDocumentMotionImageInserter(&sv.MotionImageInserter, value); err != nil { 12965 return err 12966 } 12967 12968 case "nielsenConfiguration": 12969 if err := awsRestjson1_deserializeDocumentNielsenConfiguration(&sv.NielsenConfiguration, value); err != nil { 12970 return err 12971 } 12972 12973 case "nielsenNonLinearWatermark": 12974 if err := awsRestjson1_deserializeDocumentNielsenNonLinearWatermarkSettings(&sv.NielsenNonLinearWatermark, value); err != nil { 12975 return err 12976 } 12977 12978 case "outputGroups": 12979 if err := awsRestjson1_deserializeDocument__listOfOutputGroup(&sv.OutputGroups, value); err != nil { 12980 return err 12981 } 12982 12983 case "timecodeConfig": 12984 if err := awsRestjson1_deserializeDocumentTimecodeConfig(&sv.TimecodeConfig, value); err != nil { 12985 return err 12986 } 12987 12988 case "timedMetadataInsertion": 12989 if err := awsRestjson1_deserializeDocumentTimedMetadataInsertion(&sv.TimedMetadataInsertion, value); err != nil { 12990 return err 12991 } 12992 12993 default: 12994 _, _ = key, value 12995 12996 } 12997 } 12998 *v = sv 12999 return nil 13000} 13001 13002func awsRestjson1_deserializeDocumentM2tsScte35Esam(v **types.M2tsScte35Esam, value interface{}) error { 13003 if v == nil { 13004 return fmt.Errorf("unexpected nil of type %T", v) 13005 } 13006 if value == nil { 13007 return nil 13008 } 13009 13010 shape, ok := value.(map[string]interface{}) 13011 if !ok { 13012 return fmt.Errorf("unexpected JSON type %v", value) 13013 } 13014 13015 var sv *types.M2tsScte35Esam 13016 if *v == nil { 13017 sv = &types.M2tsScte35Esam{} 13018 } else { 13019 sv = *v 13020 } 13021 13022 for key, value := range shape { 13023 switch key { 13024 case "scte35EsamPid": 13025 if value != nil { 13026 jtv, ok := value.(json.Number) 13027 if !ok { 13028 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 13029 } 13030 i64, err := jtv.Int64() 13031 if err != nil { 13032 return err 13033 } 13034 sv.Scte35EsamPid = int32(i64) 13035 } 13036 13037 default: 13038 _, _ = key, value 13039 13040 } 13041 } 13042 *v = sv 13043 return nil 13044} 13045 13046func awsRestjson1_deserializeDocumentM2tsSettings(v **types.M2tsSettings, value interface{}) error { 13047 if v == nil { 13048 return fmt.Errorf("unexpected nil of type %T", v) 13049 } 13050 if value == nil { 13051 return nil 13052 } 13053 13054 shape, ok := value.(map[string]interface{}) 13055 if !ok { 13056 return fmt.Errorf("unexpected JSON type %v", value) 13057 } 13058 13059 var sv *types.M2tsSettings 13060 if *v == nil { 13061 sv = &types.M2tsSettings{} 13062 } else { 13063 sv = *v 13064 } 13065 13066 for key, value := range shape { 13067 switch key { 13068 case "audioBufferModel": 13069 if value != nil { 13070 jtv, ok := value.(string) 13071 if !ok { 13072 return fmt.Errorf("expected M2tsAudioBufferModel to be of type string, got %T instead", value) 13073 } 13074 sv.AudioBufferModel = types.M2tsAudioBufferModel(jtv) 13075 } 13076 13077 case "audioDuration": 13078 if value != nil { 13079 jtv, ok := value.(string) 13080 if !ok { 13081 return fmt.Errorf("expected M2tsAudioDuration to be of type string, got %T instead", value) 13082 } 13083 sv.AudioDuration = types.M2tsAudioDuration(jtv) 13084 } 13085 13086 case "audioFramesPerPes": 13087 if value != nil { 13088 jtv, ok := value.(json.Number) 13089 if !ok { 13090 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 13091 } 13092 i64, err := jtv.Int64() 13093 if err != nil { 13094 return err 13095 } 13096 sv.AudioFramesPerPes = int32(i64) 13097 } 13098 13099 case "audioPids": 13100 if err := awsRestjson1_deserializeDocument__listOf__integerMin32Max8182(&sv.AudioPids, value); err != nil { 13101 return err 13102 } 13103 13104 case "bitrate": 13105 if value != nil { 13106 jtv, ok := value.(json.Number) 13107 if !ok { 13108 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 13109 } 13110 i64, err := jtv.Int64() 13111 if err != nil { 13112 return err 13113 } 13114 sv.Bitrate = int32(i64) 13115 } 13116 13117 case "bufferModel": 13118 if value != nil { 13119 jtv, ok := value.(string) 13120 if !ok { 13121 return fmt.Errorf("expected M2tsBufferModel to be of type string, got %T instead", value) 13122 } 13123 sv.BufferModel = types.M2tsBufferModel(jtv) 13124 } 13125 13126 case "dvbNitSettings": 13127 if err := awsRestjson1_deserializeDocumentDvbNitSettings(&sv.DvbNitSettings, value); err != nil { 13128 return err 13129 } 13130 13131 case "dvbSdtSettings": 13132 if err := awsRestjson1_deserializeDocumentDvbSdtSettings(&sv.DvbSdtSettings, value); err != nil { 13133 return err 13134 } 13135 13136 case "dvbSubPids": 13137 if err := awsRestjson1_deserializeDocument__listOf__integerMin32Max8182(&sv.DvbSubPids, value); err != nil { 13138 return err 13139 } 13140 13141 case "dvbTdtSettings": 13142 if err := awsRestjson1_deserializeDocumentDvbTdtSettings(&sv.DvbTdtSettings, value); err != nil { 13143 return err 13144 } 13145 13146 case "dvbTeletextPid": 13147 if value != nil { 13148 jtv, ok := value.(json.Number) 13149 if !ok { 13150 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 13151 } 13152 i64, err := jtv.Int64() 13153 if err != nil { 13154 return err 13155 } 13156 sv.DvbTeletextPid = int32(i64) 13157 } 13158 13159 case "ebpAudioInterval": 13160 if value != nil { 13161 jtv, ok := value.(string) 13162 if !ok { 13163 return fmt.Errorf("expected M2tsEbpAudioInterval to be of type string, got %T instead", value) 13164 } 13165 sv.EbpAudioInterval = types.M2tsEbpAudioInterval(jtv) 13166 } 13167 13168 case "ebpPlacement": 13169 if value != nil { 13170 jtv, ok := value.(string) 13171 if !ok { 13172 return fmt.Errorf("expected M2tsEbpPlacement to be of type string, got %T instead", value) 13173 } 13174 sv.EbpPlacement = types.M2tsEbpPlacement(jtv) 13175 } 13176 13177 case "esRateInPes": 13178 if value != nil { 13179 jtv, ok := value.(string) 13180 if !ok { 13181 return fmt.Errorf("expected M2tsEsRateInPes to be of type string, got %T instead", value) 13182 } 13183 sv.EsRateInPes = types.M2tsEsRateInPes(jtv) 13184 } 13185 13186 case "forceTsVideoEbpOrder": 13187 if value != nil { 13188 jtv, ok := value.(string) 13189 if !ok { 13190 return fmt.Errorf("expected M2tsForceTsVideoEbpOrder to be of type string, got %T instead", value) 13191 } 13192 sv.ForceTsVideoEbpOrder = types.M2tsForceTsVideoEbpOrder(jtv) 13193 } 13194 13195 case "fragmentTime": 13196 if value != nil { 13197 jtv, ok := value.(json.Number) 13198 if !ok { 13199 return fmt.Errorf("expected __doubleMin0 to be json.Number, got %T instead", value) 13200 } 13201 f64, err := jtv.Float64() 13202 if err != nil { 13203 return err 13204 } 13205 sv.FragmentTime = f64 13206 } 13207 13208 case "maxPcrInterval": 13209 if value != nil { 13210 jtv, ok := value.(json.Number) 13211 if !ok { 13212 return fmt.Errorf("expected __integerMin0Max500 to be json.Number, got %T instead", value) 13213 } 13214 i64, err := jtv.Int64() 13215 if err != nil { 13216 return err 13217 } 13218 sv.MaxPcrInterval = int32(i64) 13219 } 13220 13221 case "minEbpInterval": 13222 if value != nil { 13223 jtv, ok := value.(json.Number) 13224 if !ok { 13225 return fmt.Errorf("expected __integerMin0Max10000 to be json.Number, got %T instead", value) 13226 } 13227 i64, err := jtv.Int64() 13228 if err != nil { 13229 return err 13230 } 13231 sv.MinEbpInterval = int32(i64) 13232 } 13233 13234 case "nielsenId3": 13235 if value != nil { 13236 jtv, ok := value.(string) 13237 if !ok { 13238 return fmt.Errorf("expected M2tsNielsenId3 to be of type string, got %T instead", value) 13239 } 13240 sv.NielsenId3 = types.M2tsNielsenId3(jtv) 13241 } 13242 13243 case "nullPacketBitrate": 13244 if value != nil { 13245 jtv, ok := value.(json.Number) 13246 if !ok { 13247 return fmt.Errorf("expected __doubleMin0 to be json.Number, got %T instead", value) 13248 } 13249 f64, err := jtv.Float64() 13250 if err != nil { 13251 return err 13252 } 13253 sv.NullPacketBitrate = f64 13254 } 13255 13256 case "patInterval": 13257 if value != nil { 13258 jtv, ok := value.(json.Number) 13259 if !ok { 13260 return fmt.Errorf("expected __integerMin0Max1000 to be json.Number, got %T instead", value) 13261 } 13262 i64, err := jtv.Int64() 13263 if err != nil { 13264 return err 13265 } 13266 sv.PatInterval = int32(i64) 13267 } 13268 13269 case "pcrControl": 13270 if value != nil { 13271 jtv, ok := value.(string) 13272 if !ok { 13273 return fmt.Errorf("expected M2tsPcrControl to be of type string, got %T instead", value) 13274 } 13275 sv.PcrControl = types.M2tsPcrControl(jtv) 13276 } 13277 13278 case "pcrPid": 13279 if value != nil { 13280 jtv, ok := value.(json.Number) 13281 if !ok { 13282 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 13283 } 13284 i64, err := jtv.Int64() 13285 if err != nil { 13286 return err 13287 } 13288 sv.PcrPid = int32(i64) 13289 } 13290 13291 case "pmtInterval": 13292 if value != nil { 13293 jtv, ok := value.(json.Number) 13294 if !ok { 13295 return fmt.Errorf("expected __integerMin0Max1000 to be json.Number, got %T instead", value) 13296 } 13297 i64, err := jtv.Int64() 13298 if err != nil { 13299 return err 13300 } 13301 sv.PmtInterval = int32(i64) 13302 } 13303 13304 case "pmtPid": 13305 if value != nil { 13306 jtv, ok := value.(json.Number) 13307 if !ok { 13308 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 13309 } 13310 i64, err := jtv.Int64() 13311 if err != nil { 13312 return err 13313 } 13314 sv.PmtPid = int32(i64) 13315 } 13316 13317 case "privateMetadataPid": 13318 if value != nil { 13319 jtv, ok := value.(json.Number) 13320 if !ok { 13321 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 13322 } 13323 i64, err := jtv.Int64() 13324 if err != nil { 13325 return err 13326 } 13327 sv.PrivateMetadataPid = int32(i64) 13328 } 13329 13330 case "programNumber": 13331 if value != nil { 13332 jtv, ok := value.(json.Number) 13333 if !ok { 13334 return fmt.Errorf("expected __integerMin0Max65535 to be json.Number, got %T instead", value) 13335 } 13336 i64, err := jtv.Int64() 13337 if err != nil { 13338 return err 13339 } 13340 sv.ProgramNumber = int32(i64) 13341 } 13342 13343 case "rateMode": 13344 if value != nil { 13345 jtv, ok := value.(string) 13346 if !ok { 13347 return fmt.Errorf("expected M2tsRateMode to be of type string, got %T instead", value) 13348 } 13349 sv.RateMode = types.M2tsRateMode(jtv) 13350 } 13351 13352 case "scte35Esam": 13353 if err := awsRestjson1_deserializeDocumentM2tsScte35Esam(&sv.Scte35Esam, value); err != nil { 13354 return err 13355 } 13356 13357 case "scte35Pid": 13358 if value != nil { 13359 jtv, ok := value.(json.Number) 13360 if !ok { 13361 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 13362 } 13363 i64, err := jtv.Int64() 13364 if err != nil { 13365 return err 13366 } 13367 sv.Scte35Pid = int32(i64) 13368 } 13369 13370 case "scte35Source": 13371 if value != nil { 13372 jtv, ok := value.(string) 13373 if !ok { 13374 return fmt.Errorf("expected M2tsScte35Source to be of type string, got %T instead", value) 13375 } 13376 sv.Scte35Source = types.M2tsScte35Source(jtv) 13377 } 13378 13379 case "segmentationMarkers": 13380 if value != nil { 13381 jtv, ok := value.(string) 13382 if !ok { 13383 return fmt.Errorf("expected M2tsSegmentationMarkers to be of type string, got %T instead", value) 13384 } 13385 sv.SegmentationMarkers = types.M2tsSegmentationMarkers(jtv) 13386 } 13387 13388 case "segmentationStyle": 13389 if value != nil { 13390 jtv, ok := value.(string) 13391 if !ok { 13392 return fmt.Errorf("expected M2tsSegmentationStyle to be of type string, got %T instead", value) 13393 } 13394 sv.SegmentationStyle = types.M2tsSegmentationStyle(jtv) 13395 } 13396 13397 case "segmentationTime": 13398 if value != nil { 13399 jtv, ok := value.(json.Number) 13400 if !ok { 13401 return fmt.Errorf("expected __doubleMin0 to be json.Number, got %T instead", value) 13402 } 13403 f64, err := jtv.Float64() 13404 if err != nil { 13405 return err 13406 } 13407 sv.SegmentationTime = f64 13408 } 13409 13410 case "timedMetadataPid": 13411 if value != nil { 13412 jtv, ok := value.(json.Number) 13413 if !ok { 13414 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 13415 } 13416 i64, err := jtv.Int64() 13417 if err != nil { 13418 return err 13419 } 13420 sv.TimedMetadataPid = int32(i64) 13421 } 13422 13423 case "transportStreamId": 13424 if value != nil { 13425 jtv, ok := value.(json.Number) 13426 if !ok { 13427 return fmt.Errorf("expected __integerMin0Max65535 to be json.Number, got %T instead", value) 13428 } 13429 i64, err := jtv.Int64() 13430 if err != nil { 13431 return err 13432 } 13433 sv.TransportStreamId = int32(i64) 13434 } 13435 13436 case "videoPid": 13437 if value != nil { 13438 jtv, ok := value.(json.Number) 13439 if !ok { 13440 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 13441 } 13442 i64, err := jtv.Int64() 13443 if err != nil { 13444 return err 13445 } 13446 sv.VideoPid = int32(i64) 13447 } 13448 13449 default: 13450 _, _ = key, value 13451 13452 } 13453 } 13454 *v = sv 13455 return nil 13456} 13457 13458func awsRestjson1_deserializeDocumentM3u8Settings(v **types.M3u8Settings, value interface{}) error { 13459 if v == nil { 13460 return fmt.Errorf("unexpected nil of type %T", v) 13461 } 13462 if value == nil { 13463 return nil 13464 } 13465 13466 shape, ok := value.(map[string]interface{}) 13467 if !ok { 13468 return fmt.Errorf("unexpected JSON type %v", value) 13469 } 13470 13471 var sv *types.M3u8Settings 13472 if *v == nil { 13473 sv = &types.M3u8Settings{} 13474 } else { 13475 sv = *v 13476 } 13477 13478 for key, value := range shape { 13479 switch key { 13480 case "audioDuration": 13481 if value != nil { 13482 jtv, ok := value.(string) 13483 if !ok { 13484 return fmt.Errorf("expected M3u8AudioDuration to be of type string, got %T instead", value) 13485 } 13486 sv.AudioDuration = types.M3u8AudioDuration(jtv) 13487 } 13488 13489 case "audioFramesPerPes": 13490 if value != nil { 13491 jtv, ok := value.(json.Number) 13492 if !ok { 13493 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 13494 } 13495 i64, err := jtv.Int64() 13496 if err != nil { 13497 return err 13498 } 13499 sv.AudioFramesPerPes = int32(i64) 13500 } 13501 13502 case "audioPids": 13503 if err := awsRestjson1_deserializeDocument__listOf__integerMin32Max8182(&sv.AudioPids, value); err != nil { 13504 return err 13505 } 13506 13507 case "nielsenId3": 13508 if value != nil { 13509 jtv, ok := value.(string) 13510 if !ok { 13511 return fmt.Errorf("expected M3u8NielsenId3 to be of type string, got %T instead", value) 13512 } 13513 sv.NielsenId3 = types.M3u8NielsenId3(jtv) 13514 } 13515 13516 case "patInterval": 13517 if value != nil { 13518 jtv, ok := value.(json.Number) 13519 if !ok { 13520 return fmt.Errorf("expected __integerMin0Max1000 to be json.Number, got %T instead", value) 13521 } 13522 i64, err := jtv.Int64() 13523 if err != nil { 13524 return err 13525 } 13526 sv.PatInterval = int32(i64) 13527 } 13528 13529 case "pcrControl": 13530 if value != nil { 13531 jtv, ok := value.(string) 13532 if !ok { 13533 return fmt.Errorf("expected M3u8PcrControl to be of type string, got %T instead", value) 13534 } 13535 sv.PcrControl = types.M3u8PcrControl(jtv) 13536 } 13537 13538 case "pcrPid": 13539 if value != nil { 13540 jtv, ok := value.(json.Number) 13541 if !ok { 13542 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 13543 } 13544 i64, err := jtv.Int64() 13545 if err != nil { 13546 return err 13547 } 13548 sv.PcrPid = int32(i64) 13549 } 13550 13551 case "pmtInterval": 13552 if value != nil { 13553 jtv, ok := value.(json.Number) 13554 if !ok { 13555 return fmt.Errorf("expected __integerMin0Max1000 to be json.Number, got %T instead", value) 13556 } 13557 i64, err := jtv.Int64() 13558 if err != nil { 13559 return err 13560 } 13561 sv.PmtInterval = int32(i64) 13562 } 13563 13564 case "pmtPid": 13565 if value != nil { 13566 jtv, ok := value.(json.Number) 13567 if !ok { 13568 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 13569 } 13570 i64, err := jtv.Int64() 13571 if err != nil { 13572 return err 13573 } 13574 sv.PmtPid = int32(i64) 13575 } 13576 13577 case "privateMetadataPid": 13578 if value != nil { 13579 jtv, ok := value.(json.Number) 13580 if !ok { 13581 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 13582 } 13583 i64, err := jtv.Int64() 13584 if err != nil { 13585 return err 13586 } 13587 sv.PrivateMetadataPid = int32(i64) 13588 } 13589 13590 case "programNumber": 13591 if value != nil { 13592 jtv, ok := value.(json.Number) 13593 if !ok { 13594 return fmt.Errorf("expected __integerMin0Max65535 to be json.Number, got %T instead", value) 13595 } 13596 i64, err := jtv.Int64() 13597 if err != nil { 13598 return err 13599 } 13600 sv.ProgramNumber = int32(i64) 13601 } 13602 13603 case "scte35Pid": 13604 if value != nil { 13605 jtv, ok := value.(json.Number) 13606 if !ok { 13607 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 13608 } 13609 i64, err := jtv.Int64() 13610 if err != nil { 13611 return err 13612 } 13613 sv.Scte35Pid = int32(i64) 13614 } 13615 13616 case "scte35Source": 13617 if value != nil { 13618 jtv, ok := value.(string) 13619 if !ok { 13620 return fmt.Errorf("expected M3u8Scte35Source to be of type string, got %T instead", value) 13621 } 13622 sv.Scte35Source = types.M3u8Scte35Source(jtv) 13623 } 13624 13625 case "timedMetadata": 13626 if value != nil { 13627 jtv, ok := value.(string) 13628 if !ok { 13629 return fmt.Errorf("expected TimedMetadata to be of type string, got %T instead", value) 13630 } 13631 sv.TimedMetadata = types.TimedMetadata(jtv) 13632 } 13633 13634 case "timedMetadataPid": 13635 if value != nil { 13636 jtv, ok := value.(json.Number) 13637 if !ok { 13638 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 13639 } 13640 i64, err := jtv.Int64() 13641 if err != nil { 13642 return err 13643 } 13644 sv.TimedMetadataPid = int32(i64) 13645 } 13646 13647 case "transportStreamId": 13648 if value != nil { 13649 jtv, ok := value.(json.Number) 13650 if !ok { 13651 return fmt.Errorf("expected __integerMin0Max65535 to be json.Number, got %T instead", value) 13652 } 13653 i64, err := jtv.Int64() 13654 if err != nil { 13655 return err 13656 } 13657 sv.TransportStreamId = int32(i64) 13658 } 13659 13660 case "videoPid": 13661 if value != nil { 13662 jtv, ok := value.(json.Number) 13663 if !ok { 13664 return fmt.Errorf("expected __integerMin32Max8182 to be json.Number, got %T instead", value) 13665 } 13666 i64, err := jtv.Int64() 13667 if err != nil { 13668 return err 13669 } 13670 sv.VideoPid = int32(i64) 13671 } 13672 13673 default: 13674 _, _ = key, value 13675 13676 } 13677 } 13678 *v = sv 13679 return nil 13680} 13681 13682func awsRestjson1_deserializeDocumentMotionImageInserter(v **types.MotionImageInserter, value interface{}) error { 13683 if v == nil { 13684 return fmt.Errorf("unexpected nil of type %T", v) 13685 } 13686 if value == nil { 13687 return nil 13688 } 13689 13690 shape, ok := value.(map[string]interface{}) 13691 if !ok { 13692 return fmt.Errorf("unexpected JSON type %v", value) 13693 } 13694 13695 var sv *types.MotionImageInserter 13696 if *v == nil { 13697 sv = &types.MotionImageInserter{} 13698 } else { 13699 sv = *v 13700 } 13701 13702 for key, value := range shape { 13703 switch key { 13704 case "framerate": 13705 if err := awsRestjson1_deserializeDocumentMotionImageInsertionFramerate(&sv.Framerate, value); err != nil { 13706 return err 13707 } 13708 13709 case "input": 13710 if value != nil { 13711 jtv, ok := value.(string) 13712 if !ok { 13713 return fmt.Errorf("expected __stringMin14Max1285PatternS3Mov09PngHttpsMov09Png to be of type string, got %T instead", value) 13714 } 13715 sv.Input = ptr.String(jtv) 13716 } 13717 13718 case "insertionMode": 13719 if value != nil { 13720 jtv, ok := value.(string) 13721 if !ok { 13722 return fmt.Errorf("expected MotionImageInsertionMode to be of type string, got %T instead", value) 13723 } 13724 sv.InsertionMode = types.MotionImageInsertionMode(jtv) 13725 } 13726 13727 case "offset": 13728 if err := awsRestjson1_deserializeDocumentMotionImageInsertionOffset(&sv.Offset, value); err != nil { 13729 return err 13730 } 13731 13732 case "playback": 13733 if value != nil { 13734 jtv, ok := value.(string) 13735 if !ok { 13736 return fmt.Errorf("expected MotionImagePlayback to be of type string, got %T instead", value) 13737 } 13738 sv.Playback = types.MotionImagePlayback(jtv) 13739 } 13740 13741 case "startTime": 13742 if value != nil { 13743 jtv, ok := value.(string) 13744 if !ok { 13745 return fmt.Errorf("expected __stringMin11Max11Pattern01D20305D205D to be of type string, got %T instead", value) 13746 } 13747 sv.StartTime = ptr.String(jtv) 13748 } 13749 13750 default: 13751 _, _ = key, value 13752 13753 } 13754 } 13755 *v = sv 13756 return nil 13757} 13758 13759func awsRestjson1_deserializeDocumentMotionImageInsertionFramerate(v **types.MotionImageInsertionFramerate, value interface{}) error { 13760 if v == nil { 13761 return fmt.Errorf("unexpected nil of type %T", v) 13762 } 13763 if value == nil { 13764 return nil 13765 } 13766 13767 shape, ok := value.(map[string]interface{}) 13768 if !ok { 13769 return fmt.Errorf("unexpected JSON type %v", value) 13770 } 13771 13772 var sv *types.MotionImageInsertionFramerate 13773 if *v == nil { 13774 sv = &types.MotionImageInsertionFramerate{} 13775 } else { 13776 sv = *v 13777 } 13778 13779 for key, value := range shape { 13780 switch key { 13781 case "framerateDenominator": 13782 if value != nil { 13783 jtv, ok := value.(json.Number) 13784 if !ok { 13785 return fmt.Errorf("expected __integerMin1Max17895697 to be json.Number, got %T instead", value) 13786 } 13787 i64, err := jtv.Int64() 13788 if err != nil { 13789 return err 13790 } 13791 sv.FramerateDenominator = int32(i64) 13792 } 13793 13794 case "framerateNumerator": 13795 if value != nil { 13796 jtv, ok := value.(json.Number) 13797 if !ok { 13798 return fmt.Errorf("expected __integerMin1Max2147483640 to be json.Number, got %T instead", value) 13799 } 13800 i64, err := jtv.Int64() 13801 if err != nil { 13802 return err 13803 } 13804 sv.FramerateNumerator = int32(i64) 13805 } 13806 13807 default: 13808 _, _ = key, value 13809 13810 } 13811 } 13812 *v = sv 13813 return nil 13814} 13815 13816func awsRestjson1_deserializeDocumentMotionImageInsertionOffset(v **types.MotionImageInsertionOffset, value interface{}) error { 13817 if v == nil { 13818 return fmt.Errorf("unexpected nil of type %T", v) 13819 } 13820 if value == nil { 13821 return nil 13822 } 13823 13824 shape, ok := value.(map[string]interface{}) 13825 if !ok { 13826 return fmt.Errorf("unexpected JSON type %v", value) 13827 } 13828 13829 var sv *types.MotionImageInsertionOffset 13830 if *v == nil { 13831 sv = &types.MotionImageInsertionOffset{} 13832 } else { 13833 sv = *v 13834 } 13835 13836 for key, value := range shape { 13837 switch key { 13838 case "imageX": 13839 if value != nil { 13840 jtv, ok := value.(json.Number) 13841 if !ok { 13842 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 13843 } 13844 i64, err := jtv.Int64() 13845 if err != nil { 13846 return err 13847 } 13848 sv.ImageX = int32(i64) 13849 } 13850 13851 case "imageY": 13852 if value != nil { 13853 jtv, ok := value.(json.Number) 13854 if !ok { 13855 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 13856 } 13857 i64, err := jtv.Int64() 13858 if err != nil { 13859 return err 13860 } 13861 sv.ImageY = int32(i64) 13862 } 13863 13864 default: 13865 _, _ = key, value 13866 13867 } 13868 } 13869 *v = sv 13870 return nil 13871} 13872 13873func awsRestjson1_deserializeDocumentMovSettings(v **types.MovSettings, value interface{}) error { 13874 if v == nil { 13875 return fmt.Errorf("unexpected nil of type %T", v) 13876 } 13877 if value == nil { 13878 return nil 13879 } 13880 13881 shape, ok := value.(map[string]interface{}) 13882 if !ok { 13883 return fmt.Errorf("unexpected JSON type %v", value) 13884 } 13885 13886 var sv *types.MovSettings 13887 if *v == nil { 13888 sv = &types.MovSettings{} 13889 } else { 13890 sv = *v 13891 } 13892 13893 for key, value := range shape { 13894 switch key { 13895 case "clapAtom": 13896 if value != nil { 13897 jtv, ok := value.(string) 13898 if !ok { 13899 return fmt.Errorf("expected MovClapAtom to be of type string, got %T instead", value) 13900 } 13901 sv.ClapAtom = types.MovClapAtom(jtv) 13902 } 13903 13904 case "cslgAtom": 13905 if value != nil { 13906 jtv, ok := value.(string) 13907 if !ok { 13908 return fmt.Errorf("expected MovCslgAtom to be of type string, got %T instead", value) 13909 } 13910 sv.CslgAtom = types.MovCslgAtom(jtv) 13911 } 13912 13913 case "mpeg2FourCCControl": 13914 if value != nil { 13915 jtv, ok := value.(string) 13916 if !ok { 13917 return fmt.Errorf("expected MovMpeg2FourCCControl to be of type string, got %T instead", value) 13918 } 13919 sv.Mpeg2FourCCControl = types.MovMpeg2FourCCControl(jtv) 13920 } 13921 13922 case "paddingControl": 13923 if value != nil { 13924 jtv, ok := value.(string) 13925 if !ok { 13926 return fmt.Errorf("expected MovPaddingControl to be of type string, got %T instead", value) 13927 } 13928 sv.PaddingControl = types.MovPaddingControl(jtv) 13929 } 13930 13931 case "reference": 13932 if value != nil { 13933 jtv, ok := value.(string) 13934 if !ok { 13935 return fmt.Errorf("expected MovReference to be of type string, got %T instead", value) 13936 } 13937 sv.Reference = types.MovReference(jtv) 13938 } 13939 13940 default: 13941 _, _ = key, value 13942 13943 } 13944 } 13945 *v = sv 13946 return nil 13947} 13948 13949func awsRestjson1_deserializeDocumentMp2Settings(v **types.Mp2Settings, value interface{}) error { 13950 if v == nil { 13951 return fmt.Errorf("unexpected nil of type %T", v) 13952 } 13953 if value == nil { 13954 return nil 13955 } 13956 13957 shape, ok := value.(map[string]interface{}) 13958 if !ok { 13959 return fmt.Errorf("unexpected JSON type %v", value) 13960 } 13961 13962 var sv *types.Mp2Settings 13963 if *v == nil { 13964 sv = &types.Mp2Settings{} 13965 } else { 13966 sv = *v 13967 } 13968 13969 for key, value := range shape { 13970 switch key { 13971 case "bitrate": 13972 if value != nil { 13973 jtv, ok := value.(json.Number) 13974 if !ok { 13975 return fmt.Errorf("expected __integerMin32000Max384000 to be json.Number, got %T instead", value) 13976 } 13977 i64, err := jtv.Int64() 13978 if err != nil { 13979 return err 13980 } 13981 sv.Bitrate = int32(i64) 13982 } 13983 13984 case "channels": 13985 if value != nil { 13986 jtv, ok := value.(json.Number) 13987 if !ok { 13988 return fmt.Errorf("expected __integerMin1Max2 to be json.Number, got %T instead", value) 13989 } 13990 i64, err := jtv.Int64() 13991 if err != nil { 13992 return err 13993 } 13994 sv.Channels = int32(i64) 13995 } 13996 13997 case "sampleRate": 13998 if value != nil { 13999 jtv, ok := value.(json.Number) 14000 if !ok { 14001 return fmt.Errorf("expected __integerMin32000Max48000 to be json.Number, got %T instead", value) 14002 } 14003 i64, err := jtv.Int64() 14004 if err != nil { 14005 return err 14006 } 14007 sv.SampleRate = int32(i64) 14008 } 14009 14010 default: 14011 _, _ = key, value 14012 14013 } 14014 } 14015 *v = sv 14016 return nil 14017} 14018 14019func awsRestjson1_deserializeDocumentMp3Settings(v **types.Mp3Settings, value interface{}) error { 14020 if v == nil { 14021 return fmt.Errorf("unexpected nil of type %T", v) 14022 } 14023 if value == nil { 14024 return nil 14025 } 14026 14027 shape, ok := value.(map[string]interface{}) 14028 if !ok { 14029 return fmt.Errorf("unexpected JSON type %v", value) 14030 } 14031 14032 var sv *types.Mp3Settings 14033 if *v == nil { 14034 sv = &types.Mp3Settings{} 14035 } else { 14036 sv = *v 14037 } 14038 14039 for key, value := range shape { 14040 switch key { 14041 case "bitrate": 14042 if value != nil { 14043 jtv, ok := value.(json.Number) 14044 if !ok { 14045 return fmt.Errorf("expected __integerMin16000Max320000 to be json.Number, got %T instead", value) 14046 } 14047 i64, err := jtv.Int64() 14048 if err != nil { 14049 return err 14050 } 14051 sv.Bitrate = int32(i64) 14052 } 14053 14054 case "channels": 14055 if value != nil { 14056 jtv, ok := value.(json.Number) 14057 if !ok { 14058 return fmt.Errorf("expected __integerMin1Max2 to be json.Number, got %T instead", value) 14059 } 14060 i64, err := jtv.Int64() 14061 if err != nil { 14062 return err 14063 } 14064 sv.Channels = int32(i64) 14065 } 14066 14067 case "rateControlMode": 14068 if value != nil { 14069 jtv, ok := value.(string) 14070 if !ok { 14071 return fmt.Errorf("expected Mp3RateControlMode to be of type string, got %T instead", value) 14072 } 14073 sv.RateControlMode = types.Mp3RateControlMode(jtv) 14074 } 14075 14076 case "sampleRate": 14077 if value != nil { 14078 jtv, ok := value.(json.Number) 14079 if !ok { 14080 return fmt.Errorf("expected __integerMin22050Max48000 to be json.Number, got %T instead", value) 14081 } 14082 i64, err := jtv.Int64() 14083 if err != nil { 14084 return err 14085 } 14086 sv.SampleRate = int32(i64) 14087 } 14088 14089 case "vbrQuality": 14090 if value != nil { 14091 jtv, ok := value.(json.Number) 14092 if !ok { 14093 return fmt.Errorf("expected __integerMin0Max9 to be json.Number, got %T instead", value) 14094 } 14095 i64, err := jtv.Int64() 14096 if err != nil { 14097 return err 14098 } 14099 sv.VbrQuality = int32(i64) 14100 } 14101 14102 default: 14103 _, _ = key, value 14104 14105 } 14106 } 14107 *v = sv 14108 return nil 14109} 14110 14111func awsRestjson1_deserializeDocumentMp4Settings(v **types.Mp4Settings, value interface{}) error { 14112 if v == nil { 14113 return fmt.Errorf("unexpected nil of type %T", v) 14114 } 14115 if value == nil { 14116 return nil 14117 } 14118 14119 shape, ok := value.(map[string]interface{}) 14120 if !ok { 14121 return fmt.Errorf("unexpected JSON type %v", value) 14122 } 14123 14124 var sv *types.Mp4Settings 14125 if *v == nil { 14126 sv = &types.Mp4Settings{} 14127 } else { 14128 sv = *v 14129 } 14130 14131 for key, value := range shape { 14132 switch key { 14133 case "audioDuration": 14134 if value != nil { 14135 jtv, ok := value.(string) 14136 if !ok { 14137 return fmt.Errorf("expected CmfcAudioDuration to be of type string, got %T instead", value) 14138 } 14139 sv.AudioDuration = types.CmfcAudioDuration(jtv) 14140 } 14141 14142 case "cslgAtom": 14143 if value != nil { 14144 jtv, ok := value.(string) 14145 if !ok { 14146 return fmt.Errorf("expected Mp4CslgAtom to be of type string, got %T instead", value) 14147 } 14148 sv.CslgAtom = types.Mp4CslgAtom(jtv) 14149 } 14150 14151 case "cttsVersion": 14152 if value != nil { 14153 jtv, ok := value.(json.Number) 14154 if !ok { 14155 return fmt.Errorf("expected __integerMin0Max1 to be json.Number, got %T instead", value) 14156 } 14157 i64, err := jtv.Int64() 14158 if err != nil { 14159 return err 14160 } 14161 sv.CttsVersion = int32(i64) 14162 } 14163 14164 case "freeSpaceBox": 14165 if value != nil { 14166 jtv, ok := value.(string) 14167 if !ok { 14168 return fmt.Errorf("expected Mp4FreeSpaceBox to be of type string, got %T instead", value) 14169 } 14170 sv.FreeSpaceBox = types.Mp4FreeSpaceBox(jtv) 14171 } 14172 14173 case "moovPlacement": 14174 if value != nil { 14175 jtv, ok := value.(string) 14176 if !ok { 14177 return fmt.Errorf("expected Mp4MoovPlacement to be of type string, got %T instead", value) 14178 } 14179 sv.MoovPlacement = types.Mp4MoovPlacement(jtv) 14180 } 14181 14182 case "mp4MajorBrand": 14183 if value != nil { 14184 jtv, ok := value.(string) 14185 if !ok { 14186 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14187 } 14188 sv.Mp4MajorBrand = ptr.String(jtv) 14189 } 14190 14191 default: 14192 _, _ = key, value 14193 14194 } 14195 } 14196 *v = sv 14197 return nil 14198} 14199 14200func awsRestjson1_deserializeDocumentMpdSettings(v **types.MpdSettings, value interface{}) error { 14201 if v == nil { 14202 return fmt.Errorf("unexpected nil of type %T", v) 14203 } 14204 if value == nil { 14205 return nil 14206 } 14207 14208 shape, ok := value.(map[string]interface{}) 14209 if !ok { 14210 return fmt.Errorf("unexpected JSON type %v", value) 14211 } 14212 14213 var sv *types.MpdSettings 14214 if *v == nil { 14215 sv = &types.MpdSettings{} 14216 } else { 14217 sv = *v 14218 } 14219 14220 for key, value := range shape { 14221 switch key { 14222 case "accessibilityCaptionHints": 14223 if value != nil { 14224 jtv, ok := value.(string) 14225 if !ok { 14226 return fmt.Errorf("expected MpdAccessibilityCaptionHints to be of type string, got %T instead", value) 14227 } 14228 sv.AccessibilityCaptionHints = types.MpdAccessibilityCaptionHints(jtv) 14229 } 14230 14231 case "audioDuration": 14232 if value != nil { 14233 jtv, ok := value.(string) 14234 if !ok { 14235 return fmt.Errorf("expected MpdAudioDuration to be of type string, got %T instead", value) 14236 } 14237 sv.AudioDuration = types.MpdAudioDuration(jtv) 14238 } 14239 14240 case "captionContainerType": 14241 if value != nil { 14242 jtv, ok := value.(string) 14243 if !ok { 14244 return fmt.Errorf("expected MpdCaptionContainerType to be of type string, got %T instead", value) 14245 } 14246 sv.CaptionContainerType = types.MpdCaptionContainerType(jtv) 14247 } 14248 14249 case "scte35Esam": 14250 if value != nil { 14251 jtv, ok := value.(string) 14252 if !ok { 14253 return fmt.Errorf("expected MpdScte35Esam to be of type string, got %T instead", value) 14254 } 14255 sv.Scte35Esam = types.MpdScte35Esam(jtv) 14256 } 14257 14258 case "scte35Source": 14259 if value != nil { 14260 jtv, ok := value.(string) 14261 if !ok { 14262 return fmt.Errorf("expected MpdScte35Source to be of type string, got %T instead", value) 14263 } 14264 sv.Scte35Source = types.MpdScte35Source(jtv) 14265 } 14266 14267 default: 14268 _, _ = key, value 14269 14270 } 14271 } 14272 *v = sv 14273 return nil 14274} 14275 14276func awsRestjson1_deserializeDocumentMpeg2Settings(v **types.Mpeg2Settings, value interface{}) error { 14277 if v == nil { 14278 return fmt.Errorf("unexpected nil of type %T", v) 14279 } 14280 if value == nil { 14281 return nil 14282 } 14283 14284 shape, ok := value.(map[string]interface{}) 14285 if !ok { 14286 return fmt.Errorf("unexpected JSON type %v", value) 14287 } 14288 14289 var sv *types.Mpeg2Settings 14290 if *v == nil { 14291 sv = &types.Mpeg2Settings{} 14292 } else { 14293 sv = *v 14294 } 14295 14296 for key, value := range shape { 14297 switch key { 14298 case "adaptiveQuantization": 14299 if value != nil { 14300 jtv, ok := value.(string) 14301 if !ok { 14302 return fmt.Errorf("expected Mpeg2AdaptiveQuantization to be of type string, got %T instead", value) 14303 } 14304 sv.AdaptiveQuantization = types.Mpeg2AdaptiveQuantization(jtv) 14305 } 14306 14307 case "bitrate": 14308 if value != nil { 14309 jtv, ok := value.(json.Number) 14310 if !ok { 14311 return fmt.Errorf("expected __integerMin1000Max288000000 to be json.Number, got %T instead", value) 14312 } 14313 i64, err := jtv.Int64() 14314 if err != nil { 14315 return err 14316 } 14317 sv.Bitrate = int32(i64) 14318 } 14319 14320 case "codecLevel": 14321 if value != nil { 14322 jtv, ok := value.(string) 14323 if !ok { 14324 return fmt.Errorf("expected Mpeg2CodecLevel to be of type string, got %T instead", value) 14325 } 14326 sv.CodecLevel = types.Mpeg2CodecLevel(jtv) 14327 } 14328 14329 case "codecProfile": 14330 if value != nil { 14331 jtv, ok := value.(string) 14332 if !ok { 14333 return fmt.Errorf("expected Mpeg2CodecProfile to be of type string, got %T instead", value) 14334 } 14335 sv.CodecProfile = types.Mpeg2CodecProfile(jtv) 14336 } 14337 14338 case "dynamicSubGop": 14339 if value != nil { 14340 jtv, ok := value.(string) 14341 if !ok { 14342 return fmt.Errorf("expected Mpeg2DynamicSubGop to be of type string, got %T instead", value) 14343 } 14344 sv.DynamicSubGop = types.Mpeg2DynamicSubGop(jtv) 14345 } 14346 14347 case "framerateControl": 14348 if value != nil { 14349 jtv, ok := value.(string) 14350 if !ok { 14351 return fmt.Errorf("expected Mpeg2FramerateControl to be of type string, got %T instead", value) 14352 } 14353 sv.FramerateControl = types.Mpeg2FramerateControl(jtv) 14354 } 14355 14356 case "framerateConversionAlgorithm": 14357 if value != nil { 14358 jtv, ok := value.(string) 14359 if !ok { 14360 return fmt.Errorf("expected Mpeg2FramerateConversionAlgorithm to be of type string, got %T instead", value) 14361 } 14362 sv.FramerateConversionAlgorithm = types.Mpeg2FramerateConversionAlgorithm(jtv) 14363 } 14364 14365 case "framerateDenominator": 14366 if value != nil { 14367 jtv, ok := value.(json.Number) 14368 if !ok { 14369 return fmt.Errorf("expected __integerMin1Max1001 to be json.Number, got %T instead", value) 14370 } 14371 i64, err := jtv.Int64() 14372 if err != nil { 14373 return err 14374 } 14375 sv.FramerateDenominator = int32(i64) 14376 } 14377 14378 case "framerateNumerator": 14379 if value != nil { 14380 jtv, ok := value.(json.Number) 14381 if !ok { 14382 return fmt.Errorf("expected __integerMin24Max60000 to be json.Number, got %T instead", value) 14383 } 14384 i64, err := jtv.Int64() 14385 if err != nil { 14386 return err 14387 } 14388 sv.FramerateNumerator = int32(i64) 14389 } 14390 14391 case "gopClosedCadence": 14392 if value != nil { 14393 jtv, ok := value.(json.Number) 14394 if !ok { 14395 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 14396 } 14397 i64, err := jtv.Int64() 14398 if err != nil { 14399 return err 14400 } 14401 sv.GopClosedCadence = int32(i64) 14402 } 14403 14404 case "gopSize": 14405 if value != nil { 14406 jtv, ok := value.(json.Number) 14407 if !ok { 14408 return fmt.Errorf("expected __doubleMin0 to be json.Number, got %T instead", value) 14409 } 14410 f64, err := jtv.Float64() 14411 if err != nil { 14412 return err 14413 } 14414 sv.GopSize = f64 14415 } 14416 14417 case "gopSizeUnits": 14418 if value != nil { 14419 jtv, ok := value.(string) 14420 if !ok { 14421 return fmt.Errorf("expected Mpeg2GopSizeUnits to be of type string, got %T instead", value) 14422 } 14423 sv.GopSizeUnits = types.Mpeg2GopSizeUnits(jtv) 14424 } 14425 14426 case "hrdBufferInitialFillPercentage": 14427 if value != nil { 14428 jtv, ok := value.(json.Number) 14429 if !ok { 14430 return fmt.Errorf("expected __integerMin0Max100 to be json.Number, got %T instead", value) 14431 } 14432 i64, err := jtv.Int64() 14433 if err != nil { 14434 return err 14435 } 14436 sv.HrdBufferInitialFillPercentage = int32(i64) 14437 } 14438 14439 case "hrdBufferSize": 14440 if value != nil { 14441 jtv, ok := value.(json.Number) 14442 if !ok { 14443 return fmt.Errorf("expected __integerMin0Max47185920 to be json.Number, got %T instead", value) 14444 } 14445 i64, err := jtv.Int64() 14446 if err != nil { 14447 return err 14448 } 14449 sv.HrdBufferSize = int32(i64) 14450 } 14451 14452 case "interlaceMode": 14453 if value != nil { 14454 jtv, ok := value.(string) 14455 if !ok { 14456 return fmt.Errorf("expected Mpeg2InterlaceMode to be of type string, got %T instead", value) 14457 } 14458 sv.InterlaceMode = types.Mpeg2InterlaceMode(jtv) 14459 } 14460 14461 case "intraDcPrecision": 14462 if value != nil { 14463 jtv, ok := value.(string) 14464 if !ok { 14465 return fmt.Errorf("expected Mpeg2IntraDcPrecision to be of type string, got %T instead", value) 14466 } 14467 sv.IntraDcPrecision = types.Mpeg2IntraDcPrecision(jtv) 14468 } 14469 14470 case "maxBitrate": 14471 if value != nil { 14472 jtv, ok := value.(json.Number) 14473 if !ok { 14474 return fmt.Errorf("expected __integerMin1000Max300000000 to be json.Number, got %T instead", value) 14475 } 14476 i64, err := jtv.Int64() 14477 if err != nil { 14478 return err 14479 } 14480 sv.MaxBitrate = int32(i64) 14481 } 14482 14483 case "minIInterval": 14484 if value != nil { 14485 jtv, ok := value.(json.Number) 14486 if !ok { 14487 return fmt.Errorf("expected __integerMin0Max30 to be json.Number, got %T instead", value) 14488 } 14489 i64, err := jtv.Int64() 14490 if err != nil { 14491 return err 14492 } 14493 sv.MinIInterval = int32(i64) 14494 } 14495 14496 case "numberBFramesBetweenReferenceFrames": 14497 if value != nil { 14498 jtv, ok := value.(json.Number) 14499 if !ok { 14500 return fmt.Errorf("expected __integerMin0Max7 to be json.Number, got %T instead", value) 14501 } 14502 i64, err := jtv.Int64() 14503 if err != nil { 14504 return err 14505 } 14506 sv.NumberBFramesBetweenReferenceFrames = int32(i64) 14507 } 14508 14509 case "parControl": 14510 if value != nil { 14511 jtv, ok := value.(string) 14512 if !ok { 14513 return fmt.Errorf("expected Mpeg2ParControl to be of type string, got %T instead", value) 14514 } 14515 sv.ParControl = types.Mpeg2ParControl(jtv) 14516 } 14517 14518 case "parDenominator": 14519 if value != nil { 14520 jtv, ok := value.(json.Number) 14521 if !ok { 14522 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 14523 } 14524 i64, err := jtv.Int64() 14525 if err != nil { 14526 return err 14527 } 14528 sv.ParDenominator = int32(i64) 14529 } 14530 14531 case "parNumerator": 14532 if value != nil { 14533 jtv, ok := value.(json.Number) 14534 if !ok { 14535 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 14536 } 14537 i64, err := jtv.Int64() 14538 if err != nil { 14539 return err 14540 } 14541 sv.ParNumerator = int32(i64) 14542 } 14543 14544 case "qualityTuningLevel": 14545 if value != nil { 14546 jtv, ok := value.(string) 14547 if !ok { 14548 return fmt.Errorf("expected Mpeg2QualityTuningLevel to be of type string, got %T instead", value) 14549 } 14550 sv.QualityTuningLevel = types.Mpeg2QualityTuningLevel(jtv) 14551 } 14552 14553 case "rateControlMode": 14554 if value != nil { 14555 jtv, ok := value.(string) 14556 if !ok { 14557 return fmt.Errorf("expected Mpeg2RateControlMode to be of type string, got %T instead", value) 14558 } 14559 sv.RateControlMode = types.Mpeg2RateControlMode(jtv) 14560 } 14561 14562 case "sceneChangeDetect": 14563 if value != nil { 14564 jtv, ok := value.(string) 14565 if !ok { 14566 return fmt.Errorf("expected Mpeg2SceneChangeDetect to be of type string, got %T instead", value) 14567 } 14568 sv.SceneChangeDetect = types.Mpeg2SceneChangeDetect(jtv) 14569 } 14570 14571 case "slowPal": 14572 if value != nil { 14573 jtv, ok := value.(string) 14574 if !ok { 14575 return fmt.Errorf("expected Mpeg2SlowPal to be of type string, got %T instead", value) 14576 } 14577 sv.SlowPal = types.Mpeg2SlowPal(jtv) 14578 } 14579 14580 case "softness": 14581 if value != nil { 14582 jtv, ok := value.(json.Number) 14583 if !ok { 14584 return fmt.Errorf("expected __integerMin0Max128 to be json.Number, got %T instead", value) 14585 } 14586 i64, err := jtv.Int64() 14587 if err != nil { 14588 return err 14589 } 14590 sv.Softness = int32(i64) 14591 } 14592 14593 case "spatialAdaptiveQuantization": 14594 if value != nil { 14595 jtv, ok := value.(string) 14596 if !ok { 14597 return fmt.Errorf("expected Mpeg2SpatialAdaptiveQuantization to be of type string, got %T instead", value) 14598 } 14599 sv.SpatialAdaptiveQuantization = types.Mpeg2SpatialAdaptiveQuantization(jtv) 14600 } 14601 14602 case "syntax": 14603 if value != nil { 14604 jtv, ok := value.(string) 14605 if !ok { 14606 return fmt.Errorf("expected Mpeg2Syntax to be of type string, got %T instead", value) 14607 } 14608 sv.Syntax = types.Mpeg2Syntax(jtv) 14609 } 14610 14611 case "telecine": 14612 if value != nil { 14613 jtv, ok := value.(string) 14614 if !ok { 14615 return fmt.Errorf("expected Mpeg2Telecine to be of type string, got %T instead", value) 14616 } 14617 sv.Telecine = types.Mpeg2Telecine(jtv) 14618 } 14619 14620 case "temporalAdaptiveQuantization": 14621 if value != nil { 14622 jtv, ok := value.(string) 14623 if !ok { 14624 return fmt.Errorf("expected Mpeg2TemporalAdaptiveQuantization to be of type string, got %T instead", value) 14625 } 14626 sv.TemporalAdaptiveQuantization = types.Mpeg2TemporalAdaptiveQuantization(jtv) 14627 } 14628 14629 default: 14630 _, _ = key, value 14631 14632 } 14633 } 14634 *v = sv 14635 return nil 14636} 14637 14638func awsRestjson1_deserializeDocumentMsSmoothAdditionalManifest(v **types.MsSmoothAdditionalManifest, value interface{}) error { 14639 if v == nil { 14640 return fmt.Errorf("unexpected nil of type %T", v) 14641 } 14642 if value == nil { 14643 return nil 14644 } 14645 14646 shape, ok := value.(map[string]interface{}) 14647 if !ok { 14648 return fmt.Errorf("unexpected JSON type %v", value) 14649 } 14650 14651 var sv *types.MsSmoothAdditionalManifest 14652 if *v == nil { 14653 sv = &types.MsSmoothAdditionalManifest{} 14654 } else { 14655 sv = *v 14656 } 14657 14658 for key, value := range shape { 14659 switch key { 14660 case "manifestNameModifier": 14661 if value != nil { 14662 jtv, ok := value.(string) 14663 if !ok { 14664 return fmt.Errorf("expected __stringMin1 to be of type string, got %T instead", value) 14665 } 14666 sv.ManifestNameModifier = ptr.String(jtv) 14667 } 14668 14669 case "selectedOutputs": 14670 if err := awsRestjson1_deserializeDocument__listOf__stringMin1(&sv.SelectedOutputs, value); err != nil { 14671 return err 14672 } 14673 14674 default: 14675 _, _ = key, value 14676 14677 } 14678 } 14679 *v = sv 14680 return nil 14681} 14682 14683func awsRestjson1_deserializeDocumentMsSmoothEncryptionSettings(v **types.MsSmoothEncryptionSettings, value interface{}) error { 14684 if v == nil { 14685 return fmt.Errorf("unexpected nil of type %T", v) 14686 } 14687 if value == nil { 14688 return nil 14689 } 14690 14691 shape, ok := value.(map[string]interface{}) 14692 if !ok { 14693 return fmt.Errorf("unexpected JSON type %v", value) 14694 } 14695 14696 var sv *types.MsSmoothEncryptionSettings 14697 if *v == nil { 14698 sv = &types.MsSmoothEncryptionSettings{} 14699 } else { 14700 sv = *v 14701 } 14702 14703 for key, value := range shape { 14704 switch key { 14705 case "spekeKeyProvider": 14706 if err := awsRestjson1_deserializeDocumentSpekeKeyProvider(&sv.SpekeKeyProvider, value); err != nil { 14707 return err 14708 } 14709 14710 default: 14711 _, _ = key, value 14712 14713 } 14714 } 14715 *v = sv 14716 return nil 14717} 14718 14719func awsRestjson1_deserializeDocumentMsSmoothGroupSettings(v **types.MsSmoothGroupSettings, value interface{}) error { 14720 if v == nil { 14721 return fmt.Errorf("unexpected nil of type %T", v) 14722 } 14723 if value == nil { 14724 return nil 14725 } 14726 14727 shape, ok := value.(map[string]interface{}) 14728 if !ok { 14729 return fmt.Errorf("unexpected JSON type %v", value) 14730 } 14731 14732 var sv *types.MsSmoothGroupSettings 14733 if *v == nil { 14734 sv = &types.MsSmoothGroupSettings{} 14735 } else { 14736 sv = *v 14737 } 14738 14739 for key, value := range shape { 14740 switch key { 14741 case "additionalManifests": 14742 if err := awsRestjson1_deserializeDocument__listOfMsSmoothAdditionalManifest(&sv.AdditionalManifests, value); err != nil { 14743 return err 14744 } 14745 14746 case "audioDeduplication": 14747 if value != nil { 14748 jtv, ok := value.(string) 14749 if !ok { 14750 return fmt.Errorf("expected MsSmoothAudioDeduplication to be of type string, got %T instead", value) 14751 } 14752 sv.AudioDeduplication = types.MsSmoothAudioDeduplication(jtv) 14753 } 14754 14755 case "destination": 14756 if value != nil { 14757 jtv, ok := value.(string) 14758 if !ok { 14759 return fmt.Errorf("expected __stringPatternS3 to be of type string, got %T instead", value) 14760 } 14761 sv.Destination = ptr.String(jtv) 14762 } 14763 14764 case "destinationSettings": 14765 if err := awsRestjson1_deserializeDocumentDestinationSettings(&sv.DestinationSettings, value); err != nil { 14766 return err 14767 } 14768 14769 case "encryption": 14770 if err := awsRestjson1_deserializeDocumentMsSmoothEncryptionSettings(&sv.Encryption, value); err != nil { 14771 return err 14772 } 14773 14774 case "fragmentLength": 14775 if value != nil { 14776 jtv, ok := value.(json.Number) 14777 if !ok { 14778 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 14779 } 14780 i64, err := jtv.Int64() 14781 if err != nil { 14782 return err 14783 } 14784 sv.FragmentLength = int32(i64) 14785 } 14786 14787 case "manifestEncoding": 14788 if value != nil { 14789 jtv, ok := value.(string) 14790 if !ok { 14791 return fmt.Errorf("expected MsSmoothManifestEncoding to be of type string, got %T instead", value) 14792 } 14793 sv.ManifestEncoding = types.MsSmoothManifestEncoding(jtv) 14794 } 14795 14796 default: 14797 _, _ = key, value 14798 14799 } 14800 } 14801 *v = sv 14802 return nil 14803} 14804 14805func awsRestjson1_deserializeDocumentMxfSettings(v **types.MxfSettings, value interface{}) error { 14806 if v == nil { 14807 return fmt.Errorf("unexpected nil of type %T", v) 14808 } 14809 if value == nil { 14810 return nil 14811 } 14812 14813 shape, ok := value.(map[string]interface{}) 14814 if !ok { 14815 return fmt.Errorf("unexpected JSON type %v", value) 14816 } 14817 14818 var sv *types.MxfSettings 14819 if *v == nil { 14820 sv = &types.MxfSettings{} 14821 } else { 14822 sv = *v 14823 } 14824 14825 for key, value := range shape { 14826 switch key { 14827 case "afdSignaling": 14828 if value != nil { 14829 jtv, ok := value.(string) 14830 if !ok { 14831 return fmt.Errorf("expected MxfAfdSignaling to be of type string, got %T instead", value) 14832 } 14833 sv.AfdSignaling = types.MxfAfdSignaling(jtv) 14834 } 14835 14836 case "profile": 14837 if value != nil { 14838 jtv, ok := value.(string) 14839 if !ok { 14840 return fmt.Errorf("expected MxfProfile to be of type string, got %T instead", value) 14841 } 14842 sv.Profile = types.MxfProfile(jtv) 14843 } 14844 14845 default: 14846 _, _ = key, value 14847 14848 } 14849 } 14850 *v = sv 14851 return nil 14852} 14853 14854func awsRestjson1_deserializeDocumentNexGuardFileMarkerSettings(v **types.NexGuardFileMarkerSettings, value interface{}) error { 14855 if v == nil { 14856 return fmt.Errorf("unexpected nil of type %T", v) 14857 } 14858 if value == nil { 14859 return nil 14860 } 14861 14862 shape, ok := value.(map[string]interface{}) 14863 if !ok { 14864 return fmt.Errorf("unexpected JSON type %v", value) 14865 } 14866 14867 var sv *types.NexGuardFileMarkerSettings 14868 if *v == nil { 14869 sv = &types.NexGuardFileMarkerSettings{} 14870 } else { 14871 sv = *v 14872 } 14873 14874 for key, value := range shape { 14875 switch key { 14876 case "license": 14877 if value != nil { 14878 jtv, ok := value.(string) 14879 if !ok { 14880 return fmt.Errorf("expected __stringMin1Max100000 to be of type string, got %T instead", value) 14881 } 14882 sv.License = ptr.String(jtv) 14883 } 14884 14885 case "payload": 14886 if value != nil { 14887 jtv, ok := value.(json.Number) 14888 if !ok { 14889 return fmt.Errorf("expected __integerMin0Max4194303 to be json.Number, got %T instead", value) 14890 } 14891 i64, err := jtv.Int64() 14892 if err != nil { 14893 return err 14894 } 14895 sv.Payload = int32(i64) 14896 } 14897 14898 case "preset": 14899 if value != nil { 14900 jtv, ok := value.(string) 14901 if !ok { 14902 return fmt.Errorf("expected __stringMin1Max256 to be of type string, got %T instead", value) 14903 } 14904 sv.Preset = ptr.String(jtv) 14905 } 14906 14907 case "strength": 14908 if value != nil { 14909 jtv, ok := value.(string) 14910 if !ok { 14911 return fmt.Errorf("expected WatermarkingStrength to be of type string, got %T instead", value) 14912 } 14913 sv.Strength = types.WatermarkingStrength(jtv) 14914 } 14915 14916 default: 14917 _, _ = key, value 14918 14919 } 14920 } 14921 *v = sv 14922 return nil 14923} 14924 14925func awsRestjson1_deserializeDocumentNielsenConfiguration(v **types.NielsenConfiguration, value interface{}) error { 14926 if v == nil { 14927 return fmt.Errorf("unexpected nil of type %T", v) 14928 } 14929 if value == nil { 14930 return nil 14931 } 14932 14933 shape, ok := value.(map[string]interface{}) 14934 if !ok { 14935 return fmt.Errorf("unexpected JSON type %v", value) 14936 } 14937 14938 var sv *types.NielsenConfiguration 14939 if *v == nil { 14940 sv = &types.NielsenConfiguration{} 14941 } else { 14942 sv = *v 14943 } 14944 14945 for key, value := range shape { 14946 switch key { 14947 case "breakoutCode": 14948 if value != nil { 14949 jtv, ok := value.(json.Number) 14950 if !ok { 14951 return fmt.Errorf("expected __integerMin0Max0 to be json.Number, got %T instead", value) 14952 } 14953 i64, err := jtv.Int64() 14954 if err != nil { 14955 return err 14956 } 14957 sv.BreakoutCode = int32(i64) 14958 } 14959 14960 case "distributorId": 14961 if value != nil { 14962 jtv, ok := value.(string) 14963 if !ok { 14964 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 14965 } 14966 sv.DistributorId = ptr.String(jtv) 14967 } 14968 14969 default: 14970 _, _ = key, value 14971 14972 } 14973 } 14974 *v = sv 14975 return nil 14976} 14977 14978func awsRestjson1_deserializeDocumentNielsenNonLinearWatermarkSettings(v **types.NielsenNonLinearWatermarkSettings, value interface{}) error { 14979 if v == nil { 14980 return fmt.Errorf("unexpected nil of type %T", v) 14981 } 14982 if value == nil { 14983 return nil 14984 } 14985 14986 shape, ok := value.(map[string]interface{}) 14987 if !ok { 14988 return fmt.Errorf("unexpected JSON type %v", value) 14989 } 14990 14991 var sv *types.NielsenNonLinearWatermarkSettings 14992 if *v == nil { 14993 sv = &types.NielsenNonLinearWatermarkSettings{} 14994 } else { 14995 sv = *v 14996 } 14997 14998 for key, value := range shape { 14999 switch key { 15000 case "activeWatermarkProcess": 15001 if value != nil { 15002 jtv, ok := value.(string) 15003 if !ok { 15004 return fmt.Errorf("expected NielsenActiveWatermarkProcessType to be of type string, got %T instead", value) 15005 } 15006 sv.ActiveWatermarkProcess = types.NielsenActiveWatermarkProcessType(jtv) 15007 } 15008 15009 case "adiFilename": 15010 if value != nil { 15011 jtv, ok := value.(string) 15012 if !ok { 15013 return fmt.Errorf("expected __stringPatternS3 to be of type string, got %T instead", value) 15014 } 15015 sv.AdiFilename = ptr.String(jtv) 15016 } 15017 15018 case "assetId": 15019 if value != nil { 15020 jtv, ok := value.(string) 15021 if !ok { 15022 return fmt.Errorf("expected __stringMin1Max20 to be of type string, got %T instead", value) 15023 } 15024 sv.AssetId = ptr.String(jtv) 15025 } 15026 15027 case "assetName": 15028 if value != nil { 15029 jtv, ok := value.(string) 15030 if !ok { 15031 return fmt.Errorf("expected __stringMin1Max50 to be of type string, got %T instead", value) 15032 } 15033 sv.AssetName = ptr.String(jtv) 15034 } 15035 15036 case "cbetSourceId": 15037 if value != nil { 15038 jtv, ok := value.(string) 15039 if !ok { 15040 return fmt.Errorf("expected __stringPattern0xAFaF0908190908 to be of type string, got %T instead", value) 15041 } 15042 sv.CbetSourceId = ptr.String(jtv) 15043 } 15044 15045 case "episodeId": 15046 if value != nil { 15047 jtv, ok := value.(string) 15048 if !ok { 15049 return fmt.Errorf("expected __stringMin1Max20 to be of type string, got %T instead", value) 15050 } 15051 sv.EpisodeId = ptr.String(jtv) 15052 } 15053 15054 case "metadataDestination": 15055 if value != nil { 15056 jtv, ok := value.(string) 15057 if !ok { 15058 return fmt.Errorf("expected __stringPatternS3 to be of type string, got %T instead", value) 15059 } 15060 sv.MetadataDestination = ptr.String(jtv) 15061 } 15062 15063 case "sourceId": 15064 if value != nil { 15065 jtv, ok := value.(json.Number) 15066 if !ok { 15067 return fmt.Errorf("expected __integerMin0Max65534 to be json.Number, got %T instead", value) 15068 } 15069 i64, err := jtv.Int64() 15070 if err != nil { 15071 return err 15072 } 15073 sv.SourceId = int32(i64) 15074 } 15075 15076 case "sourceWatermarkStatus": 15077 if value != nil { 15078 jtv, ok := value.(string) 15079 if !ok { 15080 return fmt.Errorf("expected NielsenSourceWatermarkStatusType to be of type string, got %T instead", value) 15081 } 15082 sv.SourceWatermarkStatus = types.NielsenSourceWatermarkStatusType(jtv) 15083 } 15084 15085 case "ticServerUrl": 15086 if value != nil { 15087 jtv, ok := value.(string) 15088 if !ok { 15089 return fmt.Errorf("expected __stringPatternHttps to be of type string, got %T instead", value) 15090 } 15091 sv.TicServerUrl = ptr.String(jtv) 15092 } 15093 15094 case "uniqueTicPerAudioTrack": 15095 if value != nil { 15096 jtv, ok := value.(string) 15097 if !ok { 15098 return fmt.Errorf("expected NielsenUniqueTicPerAudioTrackType to be of type string, got %T instead", value) 15099 } 15100 sv.UniqueTicPerAudioTrack = types.NielsenUniqueTicPerAudioTrackType(jtv) 15101 } 15102 15103 default: 15104 _, _ = key, value 15105 15106 } 15107 } 15108 *v = sv 15109 return nil 15110} 15111 15112func awsRestjson1_deserializeDocumentNoiseReducer(v **types.NoiseReducer, value interface{}) error { 15113 if v == nil { 15114 return fmt.Errorf("unexpected nil of type %T", v) 15115 } 15116 if value == nil { 15117 return nil 15118 } 15119 15120 shape, ok := value.(map[string]interface{}) 15121 if !ok { 15122 return fmt.Errorf("unexpected JSON type %v", value) 15123 } 15124 15125 var sv *types.NoiseReducer 15126 if *v == nil { 15127 sv = &types.NoiseReducer{} 15128 } else { 15129 sv = *v 15130 } 15131 15132 for key, value := range shape { 15133 switch key { 15134 case "filter": 15135 if value != nil { 15136 jtv, ok := value.(string) 15137 if !ok { 15138 return fmt.Errorf("expected NoiseReducerFilter to be of type string, got %T instead", value) 15139 } 15140 sv.Filter = types.NoiseReducerFilter(jtv) 15141 } 15142 15143 case "filterSettings": 15144 if err := awsRestjson1_deserializeDocumentNoiseReducerFilterSettings(&sv.FilterSettings, value); err != nil { 15145 return err 15146 } 15147 15148 case "spatialFilterSettings": 15149 if err := awsRestjson1_deserializeDocumentNoiseReducerSpatialFilterSettings(&sv.SpatialFilterSettings, value); err != nil { 15150 return err 15151 } 15152 15153 case "temporalFilterSettings": 15154 if err := awsRestjson1_deserializeDocumentNoiseReducerTemporalFilterSettings(&sv.TemporalFilterSettings, value); err != nil { 15155 return err 15156 } 15157 15158 default: 15159 _, _ = key, value 15160 15161 } 15162 } 15163 *v = sv 15164 return nil 15165} 15166 15167func awsRestjson1_deserializeDocumentNoiseReducerFilterSettings(v **types.NoiseReducerFilterSettings, value interface{}) error { 15168 if v == nil { 15169 return fmt.Errorf("unexpected nil of type %T", v) 15170 } 15171 if value == nil { 15172 return nil 15173 } 15174 15175 shape, ok := value.(map[string]interface{}) 15176 if !ok { 15177 return fmt.Errorf("unexpected JSON type %v", value) 15178 } 15179 15180 var sv *types.NoiseReducerFilterSettings 15181 if *v == nil { 15182 sv = &types.NoiseReducerFilterSettings{} 15183 } else { 15184 sv = *v 15185 } 15186 15187 for key, value := range shape { 15188 switch key { 15189 case "strength": 15190 if value != nil { 15191 jtv, ok := value.(json.Number) 15192 if !ok { 15193 return fmt.Errorf("expected __integerMin0Max3 to be json.Number, got %T instead", value) 15194 } 15195 i64, err := jtv.Int64() 15196 if err != nil { 15197 return err 15198 } 15199 sv.Strength = int32(i64) 15200 } 15201 15202 default: 15203 _, _ = key, value 15204 15205 } 15206 } 15207 *v = sv 15208 return nil 15209} 15210 15211func awsRestjson1_deserializeDocumentNoiseReducerSpatialFilterSettings(v **types.NoiseReducerSpatialFilterSettings, value interface{}) error { 15212 if v == nil { 15213 return fmt.Errorf("unexpected nil of type %T", v) 15214 } 15215 if value == nil { 15216 return nil 15217 } 15218 15219 shape, ok := value.(map[string]interface{}) 15220 if !ok { 15221 return fmt.Errorf("unexpected JSON type %v", value) 15222 } 15223 15224 var sv *types.NoiseReducerSpatialFilterSettings 15225 if *v == nil { 15226 sv = &types.NoiseReducerSpatialFilterSettings{} 15227 } else { 15228 sv = *v 15229 } 15230 15231 for key, value := range shape { 15232 switch key { 15233 case "postFilterSharpenStrength": 15234 if value != nil { 15235 jtv, ok := value.(json.Number) 15236 if !ok { 15237 return fmt.Errorf("expected __integerMin0Max3 to be json.Number, got %T instead", value) 15238 } 15239 i64, err := jtv.Int64() 15240 if err != nil { 15241 return err 15242 } 15243 sv.PostFilterSharpenStrength = int32(i64) 15244 } 15245 15246 case "speed": 15247 if value != nil { 15248 jtv, ok := value.(json.Number) 15249 if !ok { 15250 return fmt.Errorf("expected __integerMinNegative2Max3 to be json.Number, got %T instead", value) 15251 } 15252 i64, err := jtv.Int64() 15253 if err != nil { 15254 return err 15255 } 15256 sv.Speed = int32(i64) 15257 } 15258 15259 case "strength": 15260 if value != nil { 15261 jtv, ok := value.(json.Number) 15262 if !ok { 15263 return fmt.Errorf("expected __integerMin0Max16 to be json.Number, got %T instead", value) 15264 } 15265 i64, err := jtv.Int64() 15266 if err != nil { 15267 return err 15268 } 15269 sv.Strength = int32(i64) 15270 } 15271 15272 default: 15273 _, _ = key, value 15274 15275 } 15276 } 15277 *v = sv 15278 return nil 15279} 15280 15281func awsRestjson1_deserializeDocumentNoiseReducerTemporalFilterSettings(v **types.NoiseReducerTemporalFilterSettings, value interface{}) error { 15282 if v == nil { 15283 return fmt.Errorf("unexpected nil of type %T", v) 15284 } 15285 if value == nil { 15286 return nil 15287 } 15288 15289 shape, ok := value.(map[string]interface{}) 15290 if !ok { 15291 return fmt.Errorf("unexpected JSON type %v", value) 15292 } 15293 15294 var sv *types.NoiseReducerTemporalFilterSettings 15295 if *v == nil { 15296 sv = &types.NoiseReducerTemporalFilterSettings{} 15297 } else { 15298 sv = *v 15299 } 15300 15301 for key, value := range shape { 15302 switch key { 15303 case "aggressiveMode": 15304 if value != nil { 15305 jtv, ok := value.(json.Number) 15306 if !ok { 15307 return fmt.Errorf("expected __integerMin0Max4 to be json.Number, got %T instead", value) 15308 } 15309 i64, err := jtv.Int64() 15310 if err != nil { 15311 return err 15312 } 15313 sv.AggressiveMode = int32(i64) 15314 } 15315 15316 case "postTemporalSharpening": 15317 if value != nil { 15318 jtv, ok := value.(string) 15319 if !ok { 15320 return fmt.Errorf("expected NoiseFilterPostTemporalSharpening to be of type string, got %T instead", value) 15321 } 15322 sv.PostTemporalSharpening = types.NoiseFilterPostTemporalSharpening(jtv) 15323 } 15324 15325 case "speed": 15326 if value != nil { 15327 jtv, ok := value.(json.Number) 15328 if !ok { 15329 return fmt.Errorf("expected __integerMinNegative1Max3 to be json.Number, got %T instead", value) 15330 } 15331 i64, err := jtv.Int64() 15332 if err != nil { 15333 return err 15334 } 15335 sv.Speed = int32(i64) 15336 } 15337 15338 case "strength": 15339 if value != nil { 15340 jtv, ok := value.(json.Number) 15341 if !ok { 15342 return fmt.Errorf("expected __integerMin0Max16 to be json.Number, got %T instead", value) 15343 } 15344 i64, err := jtv.Int64() 15345 if err != nil { 15346 return err 15347 } 15348 sv.Strength = int32(i64) 15349 } 15350 15351 default: 15352 _, _ = key, value 15353 15354 } 15355 } 15356 *v = sv 15357 return nil 15358} 15359 15360func awsRestjson1_deserializeDocumentNotFoundException(v **types.NotFoundException, value interface{}) error { 15361 if v == nil { 15362 return fmt.Errorf("unexpected nil of type %T", v) 15363 } 15364 if value == nil { 15365 return nil 15366 } 15367 15368 shape, ok := value.(map[string]interface{}) 15369 if !ok { 15370 return fmt.Errorf("unexpected JSON type %v", value) 15371 } 15372 15373 var sv *types.NotFoundException 15374 if *v == nil { 15375 sv = &types.NotFoundException{} 15376 } else { 15377 sv = *v 15378 } 15379 15380 for key, value := range shape { 15381 switch key { 15382 case "message": 15383 if value != nil { 15384 jtv, ok := value.(string) 15385 if !ok { 15386 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15387 } 15388 sv.Message = ptr.String(jtv) 15389 } 15390 15391 default: 15392 _, _ = key, value 15393 15394 } 15395 } 15396 *v = sv 15397 return nil 15398} 15399 15400func awsRestjson1_deserializeDocumentOpusSettings(v **types.OpusSettings, value interface{}) error { 15401 if v == nil { 15402 return fmt.Errorf("unexpected nil of type %T", v) 15403 } 15404 if value == nil { 15405 return nil 15406 } 15407 15408 shape, ok := value.(map[string]interface{}) 15409 if !ok { 15410 return fmt.Errorf("unexpected JSON type %v", value) 15411 } 15412 15413 var sv *types.OpusSettings 15414 if *v == nil { 15415 sv = &types.OpusSettings{} 15416 } else { 15417 sv = *v 15418 } 15419 15420 for key, value := range shape { 15421 switch key { 15422 case "bitrate": 15423 if value != nil { 15424 jtv, ok := value.(json.Number) 15425 if !ok { 15426 return fmt.Errorf("expected __integerMin32000Max192000 to be json.Number, got %T instead", value) 15427 } 15428 i64, err := jtv.Int64() 15429 if err != nil { 15430 return err 15431 } 15432 sv.Bitrate = int32(i64) 15433 } 15434 15435 case "channels": 15436 if value != nil { 15437 jtv, ok := value.(json.Number) 15438 if !ok { 15439 return fmt.Errorf("expected __integerMin1Max2 to be json.Number, got %T instead", value) 15440 } 15441 i64, err := jtv.Int64() 15442 if err != nil { 15443 return err 15444 } 15445 sv.Channels = int32(i64) 15446 } 15447 15448 case "sampleRate": 15449 if value != nil { 15450 jtv, ok := value.(json.Number) 15451 if !ok { 15452 return fmt.Errorf("expected __integerMin16000Max48000 to be json.Number, got %T instead", value) 15453 } 15454 i64, err := jtv.Int64() 15455 if err != nil { 15456 return err 15457 } 15458 sv.SampleRate = int32(i64) 15459 } 15460 15461 default: 15462 _, _ = key, value 15463 15464 } 15465 } 15466 *v = sv 15467 return nil 15468} 15469 15470func awsRestjson1_deserializeDocumentOutput(v **types.Output, value interface{}) error { 15471 if v == nil { 15472 return fmt.Errorf("unexpected nil of type %T", v) 15473 } 15474 if value == nil { 15475 return nil 15476 } 15477 15478 shape, ok := value.(map[string]interface{}) 15479 if !ok { 15480 return fmt.Errorf("unexpected JSON type %v", value) 15481 } 15482 15483 var sv *types.Output 15484 if *v == nil { 15485 sv = &types.Output{} 15486 } else { 15487 sv = *v 15488 } 15489 15490 for key, value := range shape { 15491 switch key { 15492 case "audioDescriptions": 15493 if err := awsRestjson1_deserializeDocument__listOfAudioDescription(&sv.AudioDescriptions, value); err != nil { 15494 return err 15495 } 15496 15497 case "captionDescriptions": 15498 if err := awsRestjson1_deserializeDocument__listOfCaptionDescription(&sv.CaptionDescriptions, value); err != nil { 15499 return err 15500 } 15501 15502 case "containerSettings": 15503 if err := awsRestjson1_deserializeDocumentContainerSettings(&sv.ContainerSettings, value); err != nil { 15504 return err 15505 } 15506 15507 case "extension": 15508 if value != nil { 15509 jtv, ok := value.(string) 15510 if !ok { 15511 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15512 } 15513 sv.Extension = ptr.String(jtv) 15514 } 15515 15516 case "nameModifier": 15517 if value != nil { 15518 jtv, ok := value.(string) 15519 if !ok { 15520 return fmt.Errorf("expected __stringMin1 to be of type string, got %T instead", value) 15521 } 15522 sv.NameModifier = ptr.String(jtv) 15523 } 15524 15525 case "outputSettings": 15526 if err := awsRestjson1_deserializeDocumentOutputSettings(&sv.OutputSettings, value); err != nil { 15527 return err 15528 } 15529 15530 case "preset": 15531 if value != nil { 15532 jtv, ok := value.(string) 15533 if !ok { 15534 return fmt.Errorf("expected __stringMin0 to be of type string, got %T instead", value) 15535 } 15536 sv.Preset = ptr.String(jtv) 15537 } 15538 15539 case "videoDescription": 15540 if err := awsRestjson1_deserializeDocumentVideoDescription(&sv.VideoDescription, value); err != nil { 15541 return err 15542 } 15543 15544 default: 15545 _, _ = key, value 15546 15547 } 15548 } 15549 *v = sv 15550 return nil 15551} 15552 15553func awsRestjson1_deserializeDocumentOutputChannelMapping(v **types.OutputChannelMapping, value interface{}) error { 15554 if v == nil { 15555 return fmt.Errorf("unexpected nil of type %T", v) 15556 } 15557 if value == nil { 15558 return nil 15559 } 15560 15561 shape, ok := value.(map[string]interface{}) 15562 if !ok { 15563 return fmt.Errorf("unexpected JSON type %v", value) 15564 } 15565 15566 var sv *types.OutputChannelMapping 15567 if *v == nil { 15568 sv = &types.OutputChannelMapping{} 15569 } else { 15570 sv = *v 15571 } 15572 15573 for key, value := range shape { 15574 switch key { 15575 case "inputChannels": 15576 if err := awsRestjson1_deserializeDocument__listOf__integerMinNegative60Max6(&sv.InputChannels, value); err != nil { 15577 return err 15578 } 15579 15580 default: 15581 _, _ = key, value 15582 15583 } 15584 } 15585 *v = sv 15586 return nil 15587} 15588 15589func awsRestjson1_deserializeDocumentOutputDetail(v **types.OutputDetail, value interface{}) error { 15590 if v == nil { 15591 return fmt.Errorf("unexpected nil of type %T", v) 15592 } 15593 if value == nil { 15594 return nil 15595 } 15596 15597 shape, ok := value.(map[string]interface{}) 15598 if !ok { 15599 return fmt.Errorf("unexpected JSON type %v", value) 15600 } 15601 15602 var sv *types.OutputDetail 15603 if *v == nil { 15604 sv = &types.OutputDetail{} 15605 } else { 15606 sv = *v 15607 } 15608 15609 for key, value := range shape { 15610 switch key { 15611 case "durationInMs": 15612 if value != nil { 15613 jtv, ok := value.(json.Number) 15614 if !ok { 15615 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 15616 } 15617 i64, err := jtv.Int64() 15618 if err != nil { 15619 return err 15620 } 15621 sv.DurationInMs = int32(i64) 15622 } 15623 15624 case "videoDetails": 15625 if err := awsRestjson1_deserializeDocumentVideoDetail(&sv.VideoDetails, value); err != nil { 15626 return err 15627 } 15628 15629 default: 15630 _, _ = key, value 15631 15632 } 15633 } 15634 *v = sv 15635 return nil 15636} 15637 15638func awsRestjson1_deserializeDocumentOutputGroup(v **types.OutputGroup, value interface{}) error { 15639 if v == nil { 15640 return fmt.Errorf("unexpected nil of type %T", v) 15641 } 15642 if value == nil { 15643 return nil 15644 } 15645 15646 shape, ok := value.(map[string]interface{}) 15647 if !ok { 15648 return fmt.Errorf("unexpected JSON type %v", value) 15649 } 15650 15651 var sv *types.OutputGroup 15652 if *v == nil { 15653 sv = &types.OutputGroup{} 15654 } else { 15655 sv = *v 15656 } 15657 15658 for key, value := range shape { 15659 switch key { 15660 case "automatedEncodingSettings": 15661 if err := awsRestjson1_deserializeDocumentAutomatedEncodingSettings(&sv.AutomatedEncodingSettings, value); err != nil { 15662 return err 15663 } 15664 15665 case "customName": 15666 if value != nil { 15667 jtv, ok := value.(string) 15668 if !ok { 15669 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15670 } 15671 sv.CustomName = ptr.String(jtv) 15672 } 15673 15674 case "name": 15675 if value != nil { 15676 jtv, ok := value.(string) 15677 if !ok { 15678 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15679 } 15680 sv.Name = ptr.String(jtv) 15681 } 15682 15683 case "outputGroupSettings": 15684 if err := awsRestjson1_deserializeDocumentOutputGroupSettings(&sv.OutputGroupSettings, value); err != nil { 15685 return err 15686 } 15687 15688 case "outputs": 15689 if err := awsRestjson1_deserializeDocument__listOfOutput(&sv.Outputs, value); err != nil { 15690 return err 15691 } 15692 15693 default: 15694 _, _ = key, value 15695 15696 } 15697 } 15698 *v = sv 15699 return nil 15700} 15701 15702func awsRestjson1_deserializeDocumentOutputGroupDetail(v **types.OutputGroupDetail, value interface{}) error { 15703 if v == nil { 15704 return fmt.Errorf("unexpected nil of type %T", v) 15705 } 15706 if value == nil { 15707 return nil 15708 } 15709 15710 shape, ok := value.(map[string]interface{}) 15711 if !ok { 15712 return fmt.Errorf("unexpected JSON type %v", value) 15713 } 15714 15715 var sv *types.OutputGroupDetail 15716 if *v == nil { 15717 sv = &types.OutputGroupDetail{} 15718 } else { 15719 sv = *v 15720 } 15721 15722 for key, value := range shape { 15723 switch key { 15724 case "outputDetails": 15725 if err := awsRestjson1_deserializeDocument__listOfOutputDetail(&sv.OutputDetails, value); err != nil { 15726 return err 15727 } 15728 15729 default: 15730 _, _ = key, value 15731 15732 } 15733 } 15734 *v = sv 15735 return nil 15736} 15737 15738func awsRestjson1_deserializeDocumentOutputGroupSettings(v **types.OutputGroupSettings, value interface{}) error { 15739 if v == nil { 15740 return fmt.Errorf("unexpected nil of type %T", v) 15741 } 15742 if value == nil { 15743 return nil 15744 } 15745 15746 shape, ok := value.(map[string]interface{}) 15747 if !ok { 15748 return fmt.Errorf("unexpected JSON type %v", value) 15749 } 15750 15751 var sv *types.OutputGroupSettings 15752 if *v == nil { 15753 sv = &types.OutputGroupSettings{} 15754 } else { 15755 sv = *v 15756 } 15757 15758 for key, value := range shape { 15759 switch key { 15760 case "cmafGroupSettings": 15761 if err := awsRestjson1_deserializeDocumentCmafGroupSettings(&sv.CmafGroupSettings, value); err != nil { 15762 return err 15763 } 15764 15765 case "dashIsoGroupSettings": 15766 if err := awsRestjson1_deserializeDocumentDashIsoGroupSettings(&sv.DashIsoGroupSettings, value); err != nil { 15767 return err 15768 } 15769 15770 case "fileGroupSettings": 15771 if err := awsRestjson1_deserializeDocumentFileGroupSettings(&sv.FileGroupSettings, value); err != nil { 15772 return err 15773 } 15774 15775 case "hlsGroupSettings": 15776 if err := awsRestjson1_deserializeDocumentHlsGroupSettings(&sv.HlsGroupSettings, value); err != nil { 15777 return err 15778 } 15779 15780 case "msSmoothGroupSettings": 15781 if err := awsRestjson1_deserializeDocumentMsSmoothGroupSettings(&sv.MsSmoothGroupSettings, value); err != nil { 15782 return err 15783 } 15784 15785 case "type": 15786 if value != nil { 15787 jtv, ok := value.(string) 15788 if !ok { 15789 return fmt.Errorf("expected OutputGroupType to be of type string, got %T instead", value) 15790 } 15791 sv.Type = types.OutputGroupType(jtv) 15792 } 15793 15794 default: 15795 _, _ = key, value 15796 15797 } 15798 } 15799 *v = sv 15800 return nil 15801} 15802 15803func awsRestjson1_deserializeDocumentOutputSettings(v **types.OutputSettings, value interface{}) error { 15804 if v == nil { 15805 return fmt.Errorf("unexpected nil of type %T", v) 15806 } 15807 if value == nil { 15808 return nil 15809 } 15810 15811 shape, ok := value.(map[string]interface{}) 15812 if !ok { 15813 return fmt.Errorf("unexpected JSON type %v", value) 15814 } 15815 15816 var sv *types.OutputSettings 15817 if *v == nil { 15818 sv = &types.OutputSettings{} 15819 } else { 15820 sv = *v 15821 } 15822 15823 for key, value := range shape { 15824 switch key { 15825 case "hlsSettings": 15826 if err := awsRestjson1_deserializeDocumentHlsSettings(&sv.HlsSettings, value); err != nil { 15827 return err 15828 } 15829 15830 default: 15831 _, _ = key, value 15832 15833 } 15834 } 15835 *v = sv 15836 return nil 15837} 15838 15839func awsRestjson1_deserializeDocumentPartnerWatermarking(v **types.PartnerWatermarking, value interface{}) error { 15840 if v == nil { 15841 return fmt.Errorf("unexpected nil of type %T", v) 15842 } 15843 if value == nil { 15844 return nil 15845 } 15846 15847 shape, ok := value.(map[string]interface{}) 15848 if !ok { 15849 return fmt.Errorf("unexpected JSON type %v", value) 15850 } 15851 15852 var sv *types.PartnerWatermarking 15853 if *v == nil { 15854 sv = &types.PartnerWatermarking{} 15855 } else { 15856 sv = *v 15857 } 15858 15859 for key, value := range shape { 15860 switch key { 15861 case "nexguardFileMarkerSettings": 15862 if err := awsRestjson1_deserializeDocumentNexGuardFileMarkerSettings(&sv.NexguardFileMarkerSettings, value); err != nil { 15863 return err 15864 } 15865 15866 default: 15867 _, _ = key, value 15868 15869 } 15870 } 15871 *v = sv 15872 return nil 15873} 15874 15875func awsRestjson1_deserializeDocumentPreset(v **types.Preset, value interface{}) error { 15876 if v == nil { 15877 return fmt.Errorf("unexpected nil of type %T", v) 15878 } 15879 if value == nil { 15880 return nil 15881 } 15882 15883 shape, ok := value.(map[string]interface{}) 15884 if !ok { 15885 return fmt.Errorf("unexpected JSON type %v", value) 15886 } 15887 15888 var sv *types.Preset 15889 if *v == nil { 15890 sv = &types.Preset{} 15891 } else { 15892 sv = *v 15893 } 15894 15895 for key, value := range shape { 15896 switch key { 15897 case "arn": 15898 if value != nil { 15899 jtv, ok := value.(string) 15900 if !ok { 15901 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15902 } 15903 sv.Arn = ptr.String(jtv) 15904 } 15905 15906 case "category": 15907 if value != nil { 15908 jtv, ok := value.(string) 15909 if !ok { 15910 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15911 } 15912 sv.Category = ptr.String(jtv) 15913 } 15914 15915 case "createdAt": 15916 if value != nil { 15917 jtv, ok := value.(json.Number) 15918 if !ok { 15919 return fmt.Errorf("expected __timestampUnix to be json.Number, got %T instead", value) 15920 } 15921 f64, err := jtv.Float64() 15922 if err != nil { 15923 return err 15924 } 15925 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 15926 } 15927 15928 case "description": 15929 if value != nil { 15930 jtv, ok := value.(string) 15931 if !ok { 15932 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15933 } 15934 sv.Description = ptr.String(jtv) 15935 } 15936 15937 case "lastUpdated": 15938 if value != nil { 15939 jtv, ok := value.(json.Number) 15940 if !ok { 15941 return fmt.Errorf("expected __timestampUnix to be json.Number, got %T instead", value) 15942 } 15943 f64, err := jtv.Float64() 15944 if err != nil { 15945 return err 15946 } 15947 sv.LastUpdated = ptr.Time(smithytime.ParseEpochSeconds(f64)) 15948 } 15949 15950 case "name": 15951 if value != nil { 15952 jtv, ok := value.(string) 15953 if !ok { 15954 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 15955 } 15956 sv.Name = ptr.String(jtv) 15957 } 15958 15959 case "settings": 15960 if err := awsRestjson1_deserializeDocumentPresetSettings(&sv.Settings, value); err != nil { 15961 return err 15962 } 15963 15964 case "type": 15965 if value != nil { 15966 jtv, ok := value.(string) 15967 if !ok { 15968 return fmt.Errorf("expected Type to be of type string, got %T instead", value) 15969 } 15970 sv.Type = types.Type(jtv) 15971 } 15972 15973 default: 15974 _, _ = key, value 15975 15976 } 15977 } 15978 *v = sv 15979 return nil 15980} 15981 15982func awsRestjson1_deserializeDocumentPresetSettings(v **types.PresetSettings, value interface{}) error { 15983 if v == nil { 15984 return fmt.Errorf("unexpected nil of type %T", v) 15985 } 15986 if value == nil { 15987 return nil 15988 } 15989 15990 shape, ok := value.(map[string]interface{}) 15991 if !ok { 15992 return fmt.Errorf("unexpected JSON type %v", value) 15993 } 15994 15995 var sv *types.PresetSettings 15996 if *v == nil { 15997 sv = &types.PresetSettings{} 15998 } else { 15999 sv = *v 16000 } 16001 16002 for key, value := range shape { 16003 switch key { 16004 case "audioDescriptions": 16005 if err := awsRestjson1_deserializeDocument__listOfAudioDescription(&sv.AudioDescriptions, value); err != nil { 16006 return err 16007 } 16008 16009 case "captionDescriptions": 16010 if err := awsRestjson1_deserializeDocument__listOfCaptionDescriptionPreset(&sv.CaptionDescriptions, value); err != nil { 16011 return err 16012 } 16013 16014 case "containerSettings": 16015 if err := awsRestjson1_deserializeDocumentContainerSettings(&sv.ContainerSettings, value); err != nil { 16016 return err 16017 } 16018 16019 case "videoDescription": 16020 if err := awsRestjson1_deserializeDocumentVideoDescription(&sv.VideoDescription, value); err != nil { 16021 return err 16022 } 16023 16024 default: 16025 _, _ = key, value 16026 16027 } 16028 } 16029 *v = sv 16030 return nil 16031} 16032 16033func awsRestjson1_deserializeDocumentProresSettings(v **types.ProresSettings, value interface{}) error { 16034 if v == nil { 16035 return fmt.Errorf("unexpected nil of type %T", v) 16036 } 16037 if value == nil { 16038 return nil 16039 } 16040 16041 shape, ok := value.(map[string]interface{}) 16042 if !ok { 16043 return fmt.Errorf("unexpected JSON type %v", value) 16044 } 16045 16046 var sv *types.ProresSettings 16047 if *v == nil { 16048 sv = &types.ProresSettings{} 16049 } else { 16050 sv = *v 16051 } 16052 16053 for key, value := range shape { 16054 switch key { 16055 case "codecProfile": 16056 if value != nil { 16057 jtv, ok := value.(string) 16058 if !ok { 16059 return fmt.Errorf("expected ProresCodecProfile to be of type string, got %T instead", value) 16060 } 16061 sv.CodecProfile = types.ProresCodecProfile(jtv) 16062 } 16063 16064 case "framerateControl": 16065 if value != nil { 16066 jtv, ok := value.(string) 16067 if !ok { 16068 return fmt.Errorf("expected ProresFramerateControl to be of type string, got %T instead", value) 16069 } 16070 sv.FramerateControl = types.ProresFramerateControl(jtv) 16071 } 16072 16073 case "framerateConversionAlgorithm": 16074 if value != nil { 16075 jtv, ok := value.(string) 16076 if !ok { 16077 return fmt.Errorf("expected ProresFramerateConversionAlgorithm to be of type string, got %T instead", value) 16078 } 16079 sv.FramerateConversionAlgorithm = types.ProresFramerateConversionAlgorithm(jtv) 16080 } 16081 16082 case "framerateDenominator": 16083 if value != nil { 16084 jtv, ok := value.(json.Number) 16085 if !ok { 16086 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 16087 } 16088 i64, err := jtv.Int64() 16089 if err != nil { 16090 return err 16091 } 16092 sv.FramerateDenominator = int32(i64) 16093 } 16094 16095 case "framerateNumerator": 16096 if value != nil { 16097 jtv, ok := value.(json.Number) 16098 if !ok { 16099 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 16100 } 16101 i64, err := jtv.Int64() 16102 if err != nil { 16103 return err 16104 } 16105 sv.FramerateNumerator = int32(i64) 16106 } 16107 16108 case "interlaceMode": 16109 if value != nil { 16110 jtv, ok := value.(string) 16111 if !ok { 16112 return fmt.Errorf("expected ProresInterlaceMode to be of type string, got %T instead", value) 16113 } 16114 sv.InterlaceMode = types.ProresInterlaceMode(jtv) 16115 } 16116 16117 case "parControl": 16118 if value != nil { 16119 jtv, ok := value.(string) 16120 if !ok { 16121 return fmt.Errorf("expected ProresParControl to be of type string, got %T instead", value) 16122 } 16123 sv.ParControl = types.ProresParControl(jtv) 16124 } 16125 16126 case "parDenominator": 16127 if value != nil { 16128 jtv, ok := value.(json.Number) 16129 if !ok { 16130 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 16131 } 16132 i64, err := jtv.Int64() 16133 if err != nil { 16134 return err 16135 } 16136 sv.ParDenominator = int32(i64) 16137 } 16138 16139 case "parNumerator": 16140 if value != nil { 16141 jtv, ok := value.(json.Number) 16142 if !ok { 16143 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 16144 } 16145 i64, err := jtv.Int64() 16146 if err != nil { 16147 return err 16148 } 16149 sv.ParNumerator = int32(i64) 16150 } 16151 16152 case "slowPal": 16153 if value != nil { 16154 jtv, ok := value.(string) 16155 if !ok { 16156 return fmt.Errorf("expected ProresSlowPal to be of type string, got %T instead", value) 16157 } 16158 sv.SlowPal = types.ProresSlowPal(jtv) 16159 } 16160 16161 case "telecine": 16162 if value != nil { 16163 jtv, ok := value.(string) 16164 if !ok { 16165 return fmt.Errorf("expected ProresTelecine to be of type string, got %T instead", value) 16166 } 16167 sv.Telecine = types.ProresTelecine(jtv) 16168 } 16169 16170 default: 16171 _, _ = key, value 16172 16173 } 16174 } 16175 *v = sv 16176 return nil 16177} 16178 16179func awsRestjson1_deserializeDocumentQueue(v **types.Queue, value interface{}) error { 16180 if v == nil { 16181 return fmt.Errorf("unexpected nil of type %T", v) 16182 } 16183 if value == nil { 16184 return nil 16185 } 16186 16187 shape, ok := value.(map[string]interface{}) 16188 if !ok { 16189 return fmt.Errorf("unexpected JSON type %v", value) 16190 } 16191 16192 var sv *types.Queue 16193 if *v == nil { 16194 sv = &types.Queue{} 16195 } else { 16196 sv = *v 16197 } 16198 16199 for key, value := range shape { 16200 switch key { 16201 case "arn": 16202 if value != nil { 16203 jtv, ok := value.(string) 16204 if !ok { 16205 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 16206 } 16207 sv.Arn = ptr.String(jtv) 16208 } 16209 16210 case "createdAt": 16211 if value != nil { 16212 jtv, ok := value.(json.Number) 16213 if !ok { 16214 return fmt.Errorf("expected __timestampUnix to be json.Number, got %T instead", value) 16215 } 16216 f64, err := jtv.Float64() 16217 if err != nil { 16218 return err 16219 } 16220 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 16221 } 16222 16223 case "description": 16224 if value != nil { 16225 jtv, ok := value.(string) 16226 if !ok { 16227 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 16228 } 16229 sv.Description = ptr.String(jtv) 16230 } 16231 16232 case "lastUpdated": 16233 if value != nil { 16234 jtv, ok := value.(json.Number) 16235 if !ok { 16236 return fmt.Errorf("expected __timestampUnix to be json.Number, got %T instead", value) 16237 } 16238 f64, err := jtv.Float64() 16239 if err != nil { 16240 return err 16241 } 16242 sv.LastUpdated = ptr.Time(smithytime.ParseEpochSeconds(f64)) 16243 } 16244 16245 case "name": 16246 if value != nil { 16247 jtv, ok := value.(string) 16248 if !ok { 16249 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 16250 } 16251 sv.Name = ptr.String(jtv) 16252 } 16253 16254 case "pricingPlan": 16255 if value != nil { 16256 jtv, ok := value.(string) 16257 if !ok { 16258 return fmt.Errorf("expected PricingPlan to be of type string, got %T instead", value) 16259 } 16260 sv.PricingPlan = types.PricingPlan(jtv) 16261 } 16262 16263 case "progressingJobsCount": 16264 if value != nil { 16265 jtv, ok := value.(json.Number) 16266 if !ok { 16267 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 16268 } 16269 i64, err := jtv.Int64() 16270 if err != nil { 16271 return err 16272 } 16273 sv.ProgressingJobsCount = int32(i64) 16274 } 16275 16276 case "reservationPlan": 16277 if err := awsRestjson1_deserializeDocumentReservationPlan(&sv.ReservationPlan, value); err != nil { 16278 return err 16279 } 16280 16281 case "status": 16282 if value != nil { 16283 jtv, ok := value.(string) 16284 if !ok { 16285 return fmt.Errorf("expected QueueStatus to be of type string, got %T instead", value) 16286 } 16287 sv.Status = types.QueueStatus(jtv) 16288 } 16289 16290 case "submittedJobsCount": 16291 if value != nil { 16292 jtv, ok := value.(json.Number) 16293 if !ok { 16294 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 16295 } 16296 i64, err := jtv.Int64() 16297 if err != nil { 16298 return err 16299 } 16300 sv.SubmittedJobsCount = int32(i64) 16301 } 16302 16303 case "type": 16304 if value != nil { 16305 jtv, ok := value.(string) 16306 if !ok { 16307 return fmt.Errorf("expected Type to be of type string, got %T instead", value) 16308 } 16309 sv.Type = types.Type(jtv) 16310 } 16311 16312 default: 16313 _, _ = key, value 16314 16315 } 16316 } 16317 *v = sv 16318 return nil 16319} 16320 16321func awsRestjson1_deserializeDocumentQueueTransition(v **types.QueueTransition, value interface{}) error { 16322 if v == nil { 16323 return fmt.Errorf("unexpected nil of type %T", v) 16324 } 16325 if value == nil { 16326 return nil 16327 } 16328 16329 shape, ok := value.(map[string]interface{}) 16330 if !ok { 16331 return fmt.Errorf("unexpected JSON type %v", value) 16332 } 16333 16334 var sv *types.QueueTransition 16335 if *v == nil { 16336 sv = &types.QueueTransition{} 16337 } else { 16338 sv = *v 16339 } 16340 16341 for key, value := range shape { 16342 switch key { 16343 case "destinationQueue": 16344 if value != nil { 16345 jtv, ok := value.(string) 16346 if !ok { 16347 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 16348 } 16349 sv.DestinationQueue = ptr.String(jtv) 16350 } 16351 16352 case "sourceQueue": 16353 if value != nil { 16354 jtv, ok := value.(string) 16355 if !ok { 16356 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 16357 } 16358 sv.SourceQueue = ptr.String(jtv) 16359 } 16360 16361 case "timestamp": 16362 if value != nil { 16363 jtv, ok := value.(json.Number) 16364 if !ok { 16365 return fmt.Errorf("expected __timestampUnix to be json.Number, got %T instead", value) 16366 } 16367 f64, err := jtv.Float64() 16368 if err != nil { 16369 return err 16370 } 16371 sv.Timestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 16372 } 16373 16374 default: 16375 _, _ = key, value 16376 16377 } 16378 } 16379 *v = sv 16380 return nil 16381} 16382 16383func awsRestjson1_deserializeDocumentRectangle(v **types.Rectangle, value interface{}) error { 16384 if v == nil { 16385 return fmt.Errorf("unexpected nil of type %T", v) 16386 } 16387 if value == nil { 16388 return nil 16389 } 16390 16391 shape, ok := value.(map[string]interface{}) 16392 if !ok { 16393 return fmt.Errorf("unexpected JSON type %v", value) 16394 } 16395 16396 var sv *types.Rectangle 16397 if *v == nil { 16398 sv = &types.Rectangle{} 16399 } else { 16400 sv = *v 16401 } 16402 16403 for key, value := range shape { 16404 switch key { 16405 case "height": 16406 if value != nil { 16407 jtv, ok := value.(json.Number) 16408 if !ok { 16409 return fmt.Errorf("expected __integerMin2Max2147483647 to be json.Number, got %T instead", value) 16410 } 16411 i64, err := jtv.Int64() 16412 if err != nil { 16413 return err 16414 } 16415 sv.Height = int32(i64) 16416 } 16417 16418 case "width": 16419 if value != nil { 16420 jtv, ok := value.(json.Number) 16421 if !ok { 16422 return fmt.Errorf("expected __integerMin2Max2147483647 to be json.Number, got %T instead", value) 16423 } 16424 i64, err := jtv.Int64() 16425 if err != nil { 16426 return err 16427 } 16428 sv.Width = int32(i64) 16429 } 16430 16431 case "x": 16432 if value != nil { 16433 jtv, ok := value.(json.Number) 16434 if !ok { 16435 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 16436 } 16437 i64, err := jtv.Int64() 16438 if err != nil { 16439 return err 16440 } 16441 sv.X = int32(i64) 16442 } 16443 16444 case "y": 16445 if value != nil { 16446 jtv, ok := value.(json.Number) 16447 if !ok { 16448 return fmt.Errorf("expected __integerMin0Max2147483647 to be json.Number, got %T instead", value) 16449 } 16450 i64, err := jtv.Int64() 16451 if err != nil { 16452 return err 16453 } 16454 sv.Y = int32(i64) 16455 } 16456 16457 default: 16458 _, _ = key, value 16459 16460 } 16461 } 16462 *v = sv 16463 return nil 16464} 16465 16466func awsRestjson1_deserializeDocumentRemixSettings(v **types.RemixSettings, value interface{}) error { 16467 if v == nil { 16468 return fmt.Errorf("unexpected nil of type %T", v) 16469 } 16470 if value == nil { 16471 return nil 16472 } 16473 16474 shape, ok := value.(map[string]interface{}) 16475 if !ok { 16476 return fmt.Errorf("unexpected JSON type %v", value) 16477 } 16478 16479 var sv *types.RemixSettings 16480 if *v == nil { 16481 sv = &types.RemixSettings{} 16482 } else { 16483 sv = *v 16484 } 16485 16486 for key, value := range shape { 16487 switch key { 16488 case "channelMapping": 16489 if err := awsRestjson1_deserializeDocumentChannelMapping(&sv.ChannelMapping, value); err != nil { 16490 return err 16491 } 16492 16493 case "channelsIn": 16494 if value != nil { 16495 jtv, ok := value.(json.Number) 16496 if !ok { 16497 return fmt.Errorf("expected __integerMin1Max64 to be json.Number, got %T instead", value) 16498 } 16499 i64, err := jtv.Int64() 16500 if err != nil { 16501 return err 16502 } 16503 sv.ChannelsIn = int32(i64) 16504 } 16505 16506 case "channelsOut": 16507 if value != nil { 16508 jtv, ok := value.(json.Number) 16509 if !ok { 16510 return fmt.Errorf("expected __integerMin1Max64 to be json.Number, got %T instead", value) 16511 } 16512 i64, err := jtv.Int64() 16513 if err != nil { 16514 return err 16515 } 16516 sv.ChannelsOut = int32(i64) 16517 } 16518 16519 default: 16520 _, _ = key, value 16521 16522 } 16523 } 16524 *v = sv 16525 return nil 16526} 16527 16528func awsRestjson1_deserializeDocumentReservationPlan(v **types.ReservationPlan, value interface{}) error { 16529 if v == nil { 16530 return fmt.Errorf("unexpected nil of type %T", v) 16531 } 16532 if value == nil { 16533 return nil 16534 } 16535 16536 shape, ok := value.(map[string]interface{}) 16537 if !ok { 16538 return fmt.Errorf("unexpected JSON type %v", value) 16539 } 16540 16541 var sv *types.ReservationPlan 16542 if *v == nil { 16543 sv = &types.ReservationPlan{} 16544 } else { 16545 sv = *v 16546 } 16547 16548 for key, value := range shape { 16549 switch key { 16550 case "commitment": 16551 if value != nil { 16552 jtv, ok := value.(string) 16553 if !ok { 16554 return fmt.Errorf("expected Commitment to be of type string, got %T instead", value) 16555 } 16556 sv.Commitment = types.Commitment(jtv) 16557 } 16558 16559 case "expiresAt": 16560 if value != nil { 16561 jtv, ok := value.(json.Number) 16562 if !ok { 16563 return fmt.Errorf("expected __timestampUnix to be json.Number, got %T instead", value) 16564 } 16565 f64, err := jtv.Float64() 16566 if err != nil { 16567 return err 16568 } 16569 sv.ExpiresAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 16570 } 16571 16572 case "purchasedAt": 16573 if value != nil { 16574 jtv, ok := value.(json.Number) 16575 if !ok { 16576 return fmt.Errorf("expected __timestampUnix to be json.Number, got %T instead", value) 16577 } 16578 f64, err := jtv.Float64() 16579 if err != nil { 16580 return err 16581 } 16582 sv.PurchasedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 16583 } 16584 16585 case "renewalType": 16586 if value != nil { 16587 jtv, ok := value.(string) 16588 if !ok { 16589 return fmt.Errorf("expected RenewalType to be of type string, got %T instead", value) 16590 } 16591 sv.RenewalType = types.RenewalType(jtv) 16592 } 16593 16594 case "reservedSlots": 16595 if value != nil { 16596 jtv, ok := value.(json.Number) 16597 if !ok { 16598 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 16599 } 16600 i64, err := jtv.Int64() 16601 if err != nil { 16602 return err 16603 } 16604 sv.ReservedSlots = int32(i64) 16605 } 16606 16607 case "status": 16608 if value != nil { 16609 jtv, ok := value.(string) 16610 if !ok { 16611 return fmt.Errorf("expected ReservationPlanStatus to be of type string, got %T instead", value) 16612 } 16613 sv.Status = types.ReservationPlanStatus(jtv) 16614 } 16615 16616 default: 16617 _, _ = key, value 16618 16619 } 16620 } 16621 *v = sv 16622 return nil 16623} 16624 16625func awsRestjson1_deserializeDocumentResourceTags(v **types.ResourceTags, value interface{}) error { 16626 if v == nil { 16627 return fmt.Errorf("unexpected nil of type %T", v) 16628 } 16629 if value == nil { 16630 return nil 16631 } 16632 16633 shape, ok := value.(map[string]interface{}) 16634 if !ok { 16635 return fmt.Errorf("unexpected JSON type %v", value) 16636 } 16637 16638 var sv *types.ResourceTags 16639 if *v == nil { 16640 sv = &types.ResourceTags{} 16641 } else { 16642 sv = *v 16643 } 16644 16645 for key, value := range shape { 16646 switch key { 16647 case "arn": 16648 if value != nil { 16649 jtv, ok := value.(string) 16650 if !ok { 16651 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 16652 } 16653 sv.Arn = ptr.String(jtv) 16654 } 16655 16656 case "tags": 16657 if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil { 16658 return err 16659 } 16660 16661 default: 16662 _, _ = key, value 16663 16664 } 16665 } 16666 *v = sv 16667 return nil 16668} 16669 16670func awsRestjson1_deserializeDocumentS3DestinationAccessControl(v **types.S3DestinationAccessControl, value interface{}) error { 16671 if v == nil { 16672 return fmt.Errorf("unexpected nil of type %T", v) 16673 } 16674 if value == nil { 16675 return nil 16676 } 16677 16678 shape, ok := value.(map[string]interface{}) 16679 if !ok { 16680 return fmt.Errorf("unexpected JSON type %v", value) 16681 } 16682 16683 var sv *types.S3DestinationAccessControl 16684 if *v == nil { 16685 sv = &types.S3DestinationAccessControl{} 16686 } else { 16687 sv = *v 16688 } 16689 16690 for key, value := range shape { 16691 switch key { 16692 case "cannedAcl": 16693 if value != nil { 16694 jtv, ok := value.(string) 16695 if !ok { 16696 return fmt.Errorf("expected S3ObjectCannedAcl to be of type string, got %T instead", value) 16697 } 16698 sv.CannedAcl = types.S3ObjectCannedAcl(jtv) 16699 } 16700 16701 default: 16702 _, _ = key, value 16703 16704 } 16705 } 16706 *v = sv 16707 return nil 16708} 16709 16710func awsRestjson1_deserializeDocumentS3DestinationSettings(v **types.S3DestinationSettings, value interface{}) error { 16711 if v == nil { 16712 return fmt.Errorf("unexpected nil of type %T", v) 16713 } 16714 if value == nil { 16715 return nil 16716 } 16717 16718 shape, ok := value.(map[string]interface{}) 16719 if !ok { 16720 return fmt.Errorf("unexpected JSON type %v", value) 16721 } 16722 16723 var sv *types.S3DestinationSettings 16724 if *v == nil { 16725 sv = &types.S3DestinationSettings{} 16726 } else { 16727 sv = *v 16728 } 16729 16730 for key, value := range shape { 16731 switch key { 16732 case "accessControl": 16733 if err := awsRestjson1_deserializeDocumentS3DestinationAccessControl(&sv.AccessControl, value); err != nil { 16734 return err 16735 } 16736 16737 case "encryption": 16738 if err := awsRestjson1_deserializeDocumentS3EncryptionSettings(&sv.Encryption, value); err != nil { 16739 return err 16740 } 16741 16742 default: 16743 _, _ = key, value 16744 16745 } 16746 } 16747 *v = sv 16748 return nil 16749} 16750 16751func awsRestjson1_deserializeDocumentS3EncryptionSettings(v **types.S3EncryptionSettings, value interface{}) error { 16752 if v == nil { 16753 return fmt.Errorf("unexpected nil of type %T", v) 16754 } 16755 if value == nil { 16756 return nil 16757 } 16758 16759 shape, ok := value.(map[string]interface{}) 16760 if !ok { 16761 return fmt.Errorf("unexpected JSON type %v", value) 16762 } 16763 16764 var sv *types.S3EncryptionSettings 16765 if *v == nil { 16766 sv = &types.S3EncryptionSettings{} 16767 } else { 16768 sv = *v 16769 } 16770 16771 for key, value := range shape { 16772 switch key { 16773 case "encryptionType": 16774 if value != nil { 16775 jtv, ok := value.(string) 16776 if !ok { 16777 return fmt.Errorf("expected S3ServerSideEncryptionType to be of type string, got %T instead", value) 16778 } 16779 sv.EncryptionType = types.S3ServerSideEncryptionType(jtv) 16780 } 16781 16782 case "kmsKeyArn": 16783 if value != nil { 16784 jtv, ok := value.(string) 16785 if !ok { 16786 return fmt.Errorf("expected __stringPatternArnAwsUsGovCnKmsAZ26EastWestCentralNorthSouthEastWest1912D12KeyAFAF098AFAF094AFAF094AFAF094AFAF0912 to be of type string, got %T instead", value) 16787 } 16788 sv.KmsKeyArn = ptr.String(jtv) 16789 } 16790 16791 default: 16792 _, _ = key, value 16793 16794 } 16795 } 16796 *v = sv 16797 return nil 16798} 16799 16800func awsRestjson1_deserializeDocumentSccDestinationSettings(v **types.SccDestinationSettings, value interface{}) error { 16801 if v == nil { 16802 return fmt.Errorf("unexpected nil of type %T", v) 16803 } 16804 if value == nil { 16805 return nil 16806 } 16807 16808 shape, ok := value.(map[string]interface{}) 16809 if !ok { 16810 return fmt.Errorf("unexpected JSON type %v", value) 16811 } 16812 16813 var sv *types.SccDestinationSettings 16814 if *v == nil { 16815 sv = &types.SccDestinationSettings{} 16816 } else { 16817 sv = *v 16818 } 16819 16820 for key, value := range shape { 16821 switch key { 16822 case "framerate": 16823 if value != nil { 16824 jtv, ok := value.(string) 16825 if !ok { 16826 return fmt.Errorf("expected SccDestinationFramerate to be of type string, got %T instead", value) 16827 } 16828 sv.Framerate = types.SccDestinationFramerate(jtv) 16829 } 16830 16831 default: 16832 _, _ = key, value 16833 16834 } 16835 } 16836 *v = sv 16837 return nil 16838} 16839 16840func awsRestjson1_deserializeDocumentSpekeKeyProvider(v **types.SpekeKeyProvider, value interface{}) error { 16841 if v == nil { 16842 return fmt.Errorf("unexpected nil of type %T", v) 16843 } 16844 if value == nil { 16845 return nil 16846 } 16847 16848 shape, ok := value.(map[string]interface{}) 16849 if !ok { 16850 return fmt.Errorf("unexpected JSON type %v", value) 16851 } 16852 16853 var sv *types.SpekeKeyProvider 16854 if *v == nil { 16855 sv = &types.SpekeKeyProvider{} 16856 } else { 16857 sv = *v 16858 } 16859 16860 for key, value := range shape { 16861 switch key { 16862 case "certificateArn": 16863 if value != nil { 16864 jtv, ok := value.(string) 16865 if !ok { 16866 return fmt.Errorf("expected __stringPatternArnAwsUsGovAcm to be of type string, got %T instead", value) 16867 } 16868 sv.CertificateArn = ptr.String(jtv) 16869 } 16870 16871 case "resourceId": 16872 if value != nil { 16873 jtv, ok := value.(string) 16874 if !ok { 16875 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 16876 } 16877 sv.ResourceId = ptr.String(jtv) 16878 } 16879 16880 case "systemIds": 16881 if err := awsRestjson1_deserializeDocument__listOf__stringPattern09aFAF809aFAF409aFAF409aFAF409aFAF12(&sv.SystemIds, value); err != nil { 16882 return err 16883 } 16884 16885 case "url": 16886 if value != nil { 16887 jtv, ok := value.(string) 16888 if !ok { 16889 return fmt.Errorf("expected __stringPatternHttps to be of type string, got %T instead", value) 16890 } 16891 sv.Url = ptr.String(jtv) 16892 } 16893 16894 default: 16895 _, _ = key, value 16896 16897 } 16898 } 16899 *v = sv 16900 return nil 16901} 16902 16903func awsRestjson1_deserializeDocumentSpekeKeyProviderCmaf(v **types.SpekeKeyProviderCmaf, value interface{}) error { 16904 if v == nil { 16905 return fmt.Errorf("unexpected nil of type %T", v) 16906 } 16907 if value == nil { 16908 return nil 16909 } 16910 16911 shape, ok := value.(map[string]interface{}) 16912 if !ok { 16913 return fmt.Errorf("unexpected JSON type %v", value) 16914 } 16915 16916 var sv *types.SpekeKeyProviderCmaf 16917 if *v == nil { 16918 sv = &types.SpekeKeyProviderCmaf{} 16919 } else { 16920 sv = *v 16921 } 16922 16923 for key, value := range shape { 16924 switch key { 16925 case "certificateArn": 16926 if value != nil { 16927 jtv, ok := value.(string) 16928 if !ok { 16929 return fmt.Errorf("expected __stringPatternArnAwsUsGovAcm to be of type string, got %T instead", value) 16930 } 16931 sv.CertificateArn = ptr.String(jtv) 16932 } 16933 16934 case "dashSignaledSystemIds": 16935 if err := awsRestjson1_deserializeDocument__listOf__stringMin36Max36Pattern09aFAF809aFAF409aFAF409aFAF409aFAF12(&sv.DashSignaledSystemIds, value); err != nil { 16936 return err 16937 } 16938 16939 case "hlsSignaledSystemIds": 16940 if err := awsRestjson1_deserializeDocument__listOf__stringMin36Max36Pattern09aFAF809aFAF409aFAF409aFAF409aFAF12(&sv.HlsSignaledSystemIds, value); err != nil { 16941 return err 16942 } 16943 16944 case "resourceId": 16945 if value != nil { 16946 jtv, ok := value.(string) 16947 if !ok { 16948 return fmt.Errorf("expected __stringPatternW to be of type string, got %T instead", value) 16949 } 16950 sv.ResourceId = ptr.String(jtv) 16951 } 16952 16953 case "url": 16954 if value != nil { 16955 jtv, ok := value.(string) 16956 if !ok { 16957 return fmt.Errorf("expected __stringPatternHttps to be of type string, got %T instead", value) 16958 } 16959 sv.Url = ptr.String(jtv) 16960 } 16961 16962 default: 16963 _, _ = key, value 16964 16965 } 16966 } 16967 *v = sv 16968 return nil 16969} 16970 16971func awsRestjson1_deserializeDocumentStaticKeyProvider(v **types.StaticKeyProvider, value interface{}) error { 16972 if v == nil { 16973 return fmt.Errorf("unexpected nil of type %T", v) 16974 } 16975 if value == nil { 16976 return nil 16977 } 16978 16979 shape, ok := value.(map[string]interface{}) 16980 if !ok { 16981 return fmt.Errorf("unexpected JSON type %v", value) 16982 } 16983 16984 var sv *types.StaticKeyProvider 16985 if *v == nil { 16986 sv = &types.StaticKeyProvider{} 16987 } else { 16988 sv = *v 16989 } 16990 16991 for key, value := range shape { 16992 switch key { 16993 case "keyFormat": 16994 if value != nil { 16995 jtv, ok := value.(string) 16996 if !ok { 16997 return fmt.Errorf("expected __stringPatternIdentityAZaZ26AZaZ09163 to be of type string, got %T instead", value) 16998 } 16999 sv.KeyFormat = ptr.String(jtv) 17000 } 17001 17002 case "keyFormatVersions": 17003 if value != nil { 17004 jtv, ok := value.(string) 17005 if !ok { 17006 return fmt.Errorf("expected __stringPatternDD to be of type string, got %T instead", value) 17007 } 17008 sv.KeyFormatVersions = ptr.String(jtv) 17009 } 17010 17011 case "staticKeyValue": 17012 if value != nil { 17013 jtv, ok := value.(string) 17014 if !ok { 17015 return fmt.Errorf("expected __stringPatternAZaZ0932 to be of type string, got %T instead", value) 17016 } 17017 sv.StaticKeyValue = ptr.String(jtv) 17018 } 17019 17020 case "url": 17021 if value != nil { 17022 jtv, ok := value.(string) 17023 if !ok { 17024 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 17025 } 17026 sv.Url = ptr.String(jtv) 17027 } 17028 17029 default: 17030 _, _ = key, value 17031 17032 } 17033 } 17034 *v = sv 17035 return nil 17036} 17037 17038func awsRestjson1_deserializeDocumentTeletextDestinationSettings(v **types.TeletextDestinationSettings, value interface{}) error { 17039 if v == nil { 17040 return fmt.Errorf("unexpected nil of type %T", v) 17041 } 17042 if value == nil { 17043 return nil 17044 } 17045 17046 shape, ok := value.(map[string]interface{}) 17047 if !ok { 17048 return fmt.Errorf("unexpected JSON type %v", value) 17049 } 17050 17051 var sv *types.TeletextDestinationSettings 17052 if *v == nil { 17053 sv = &types.TeletextDestinationSettings{} 17054 } else { 17055 sv = *v 17056 } 17057 17058 for key, value := range shape { 17059 switch key { 17060 case "pageNumber": 17061 if value != nil { 17062 jtv, ok := value.(string) 17063 if !ok { 17064 return fmt.Errorf("expected __stringMin3Max3Pattern1809aFAF09aEAE to be of type string, got %T instead", value) 17065 } 17066 sv.PageNumber = ptr.String(jtv) 17067 } 17068 17069 case "pageTypes": 17070 if err := awsRestjson1_deserializeDocument__listOfTeletextPageType(&sv.PageTypes, value); err != nil { 17071 return err 17072 } 17073 17074 default: 17075 _, _ = key, value 17076 17077 } 17078 } 17079 *v = sv 17080 return nil 17081} 17082 17083func awsRestjson1_deserializeDocumentTeletextSourceSettings(v **types.TeletextSourceSettings, value interface{}) error { 17084 if v == nil { 17085 return fmt.Errorf("unexpected nil of type %T", v) 17086 } 17087 if value == nil { 17088 return nil 17089 } 17090 17091 shape, ok := value.(map[string]interface{}) 17092 if !ok { 17093 return fmt.Errorf("unexpected JSON type %v", value) 17094 } 17095 17096 var sv *types.TeletextSourceSettings 17097 if *v == nil { 17098 sv = &types.TeletextSourceSettings{} 17099 } else { 17100 sv = *v 17101 } 17102 17103 for key, value := range shape { 17104 switch key { 17105 case "pageNumber": 17106 if value != nil { 17107 jtv, ok := value.(string) 17108 if !ok { 17109 return fmt.Errorf("expected __stringMin3Max3Pattern1809aFAF09aEAE to be of type string, got %T instead", value) 17110 } 17111 sv.PageNumber = ptr.String(jtv) 17112 } 17113 17114 default: 17115 _, _ = key, value 17116 17117 } 17118 } 17119 *v = sv 17120 return nil 17121} 17122 17123func awsRestjson1_deserializeDocumentTimecodeBurnin(v **types.TimecodeBurnin, value interface{}) error { 17124 if v == nil { 17125 return fmt.Errorf("unexpected nil of type %T", v) 17126 } 17127 if value == nil { 17128 return nil 17129 } 17130 17131 shape, ok := value.(map[string]interface{}) 17132 if !ok { 17133 return fmt.Errorf("unexpected JSON type %v", value) 17134 } 17135 17136 var sv *types.TimecodeBurnin 17137 if *v == nil { 17138 sv = &types.TimecodeBurnin{} 17139 } else { 17140 sv = *v 17141 } 17142 17143 for key, value := range shape { 17144 switch key { 17145 case "fontSize": 17146 if value != nil { 17147 jtv, ok := value.(json.Number) 17148 if !ok { 17149 return fmt.Errorf("expected __integerMin10Max48 to be json.Number, got %T instead", value) 17150 } 17151 i64, err := jtv.Int64() 17152 if err != nil { 17153 return err 17154 } 17155 sv.FontSize = int32(i64) 17156 } 17157 17158 case "position": 17159 if value != nil { 17160 jtv, ok := value.(string) 17161 if !ok { 17162 return fmt.Errorf("expected TimecodeBurninPosition to be of type string, got %T instead", value) 17163 } 17164 sv.Position = types.TimecodeBurninPosition(jtv) 17165 } 17166 17167 case "prefix": 17168 if value != nil { 17169 jtv, ok := value.(string) 17170 if !ok { 17171 return fmt.Errorf("expected __stringPattern to be of type string, got %T instead", value) 17172 } 17173 sv.Prefix = ptr.String(jtv) 17174 } 17175 17176 default: 17177 _, _ = key, value 17178 17179 } 17180 } 17181 *v = sv 17182 return nil 17183} 17184 17185func awsRestjson1_deserializeDocumentTimecodeConfig(v **types.TimecodeConfig, value interface{}) error { 17186 if v == nil { 17187 return fmt.Errorf("unexpected nil of type %T", v) 17188 } 17189 if value == nil { 17190 return nil 17191 } 17192 17193 shape, ok := value.(map[string]interface{}) 17194 if !ok { 17195 return fmt.Errorf("unexpected JSON type %v", value) 17196 } 17197 17198 var sv *types.TimecodeConfig 17199 if *v == nil { 17200 sv = &types.TimecodeConfig{} 17201 } else { 17202 sv = *v 17203 } 17204 17205 for key, value := range shape { 17206 switch key { 17207 case "anchor": 17208 if value != nil { 17209 jtv, ok := value.(string) 17210 if !ok { 17211 return fmt.Errorf("expected __stringPattern010920405090509092 to be of type string, got %T instead", value) 17212 } 17213 sv.Anchor = ptr.String(jtv) 17214 } 17215 17216 case "source": 17217 if value != nil { 17218 jtv, ok := value.(string) 17219 if !ok { 17220 return fmt.Errorf("expected TimecodeSource to be of type string, got %T instead", value) 17221 } 17222 sv.Source = types.TimecodeSource(jtv) 17223 } 17224 17225 case "start": 17226 if value != nil { 17227 jtv, ok := value.(string) 17228 if !ok { 17229 return fmt.Errorf("expected __stringPattern010920405090509092 to be of type string, got %T instead", value) 17230 } 17231 sv.Start = ptr.String(jtv) 17232 } 17233 17234 case "timestampOffset": 17235 if value != nil { 17236 jtv, ok := value.(string) 17237 if !ok { 17238 return fmt.Errorf("expected __stringPattern0940191020191209301 to be of type string, got %T instead", value) 17239 } 17240 sv.TimestampOffset = ptr.String(jtv) 17241 } 17242 17243 default: 17244 _, _ = key, value 17245 17246 } 17247 } 17248 *v = sv 17249 return nil 17250} 17251 17252func awsRestjson1_deserializeDocumentTimedMetadataInsertion(v **types.TimedMetadataInsertion, value interface{}) error { 17253 if v == nil { 17254 return fmt.Errorf("unexpected nil of type %T", v) 17255 } 17256 if value == nil { 17257 return nil 17258 } 17259 17260 shape, ok := value.(map[string]interface{}) 17261 if !ok { 17262 return fmt.Errorf("unexpected JSON type %v", value) 17263 } 17264 17265 var sv *types.TimedMetadataInsertion 17266 if *v == nil { 17267 sv = &types.TimedMetadataInsertion{} 17268 } else { 17269 sv = *v 17270 } 17271 17272 for key, value := range shape { 17273 switch key { 17274 case "id3Insertions": 17275 if err := awsRestjson1_deserializeDocument__listOfId3Insertion(&sv.Id3Insertions, value); err != nil { 17276 return err 17277 } 17278 17279 default: 17280 _, _ = key, value 17281 17282 } 17283 } 17284 *v = sv 17285 return nil 17286} 17287 17288func awsRestjson1_deserializeDocumentTiming(v **types.Timing, value interface{}) error { 17289 if v == nil { 17290 return fmt.Errorf("unexpected nil of type %T", v) 17291 } 17292 if value == nil { 17293 return nil 17294 } 17295 17296 shape, ok := value.(map[string]interface{}) 17297 if !ok { 17298 return fmt.Errorf("unexpected JSON type %v", value) 17299 } 17300 17301 var sv *types.Timing 17302 if *v == nil { 17303 sv = &types.Timing{} 17304 } else { 17305 sv = *v 17306 } 17307 17308 for key, value := range shape { 17309 switch key { 17310 case "finishTime": 17311 if value != nil { 17312 jtv, ok := value.(json.Number) 17313 if !ok { 17314 return fmt.Errorf("expected __timestampUnix to be json.Number, got %T instead", value) 17315 } 17316 f64, err := jtv.Float64() 17317 if err != nil { 17318 return err 17319 } 17320 sv.FinishTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 17321 } 17322 17323 case "startTime": 17324 if value != nil { 17325 jtv, ok := value.(json.Number) 17326 if !ok { 17327 return fmt.Errorf("expected __timestampUnix to be json.Number, got %T instead", value) 17328 } 17329 f64, err := jtv.Float64() 17330 if err != nil { 17331 return err 17332 } 17333 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 17334 } 17335 17336 case "submitTime": 17337 if value != nil { 17338 jtv, ok := value.(json.Number) 17339 if !ok { 17340 return fmt.Errorf("expected __timestampUnix to be json.Number, got %T instead", value) 17341 } 17342 f64, err := jtv.Float64() 17343 if err != nil { 17344 return err 17345 } 17346 sv.SubmitTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 17347 } 17348 17349 default: 17350 _, _ = key, value 17351 17352 } 17353 } 17354 *v = sv 17355 return nil 17356} 17357 17358func awsRestjson1_deserializeDocumentTooManyRequestsException(v **types.TooManyRequestsException, value interface{}) error { 17359 if v == nil { 17360 return fmt.Errorf("unexpected nil of type %T", v) 17361 } 17362 if value == nil { 17363 return nil 17364 } 17365 17366 shape, ok := value.(map[string]interface{}) 17367 if !ok { 17368 return fmt.Errorf("unexpected JSON type %v", value) 17369 } 17370 17371 var sv *types.TooManyRequestsException 17372 if *v == nil { 17373 sv = &types.TooManyRequestsException{} 17374 } else { 17375 sv = *v 17376 } 17377 17378 for key, value := range shape { 17379 switch key { 17380 case "message": 17381 if value != nil { 17382 jtv, ok := value.(string) 17383 if !ok { 17384 return fmt.Errorf("expected __string to be of type string, got %T instead", value) 17385 } 17386 sv.Message = ptr.String(jtv) 17387 } 17388 17389 default: 17390 _, _ = key, value 17391 17392 } 17393 } 17394 *v = sv 17395 return nil 17396} 17397 17398func awsRestjson1_deserializeDocumentTrackSourceSettings(v **types.TrackSourceSettings, value interface{}) error { 17399 if v == nil { 17400 return fmt.Errorf("unexpected nil of type %T", v) 17401 } 17402 if value == nil { 17403 return nil 17404 } 17405 17406 shape, ok := value.(map[string]interface{}) 17407 if !ok { 17408 return fmt.Errorf("unexpected JSON type %v", value) 17409 } 17410 17411 var sv *types.TrackSourceSettings 17412 if *v == nil { 17413 sv = &types.TrackSourceSettings{} 17414 } else { 17415 sv = *v 17416 } 17417 17418 for key, value := range shape { 17419 switch key { 17420 case "trackNumber": 17421 if value != nil { 17422 jtv, ok := value.(json.Number) 17423 if !ok { 17424 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 17425 } 17426 i64, err := jtv.Int64() 17427 if err != nil { 17428 return err 17429 } 17430 sv.TrackNumber = int32(i64) 17431 } 17432 17433 default: 17434 _, _ = key, value 17435 17436 } 17437 } 17438 *v = sv 17439 return nil 17440} 17441 17442func awsRestjson1_deserializeDocumentTtmlDestinationSettings(v **types.TtmlDestinationSettings, value interface{}) error { 17443 if v == nil { 17444 return fmt.Errorf("unexpected nil of type %T", v) 17445 } 17446 if value == nil { 17447 return nil 17448 } 17449 17450 shape, ok := value.(map[string]interface{}) 17451 if !ok { 17452 return fmt.Errorf("unexpected JSON type %v", value) 17453 } 17454 17455 var sv *types.TtmlDestinationSettings 17456 if *v == nil { 17457 sv = &types.TtmlDestinationSettings{} 17458 } else { 17459 sv = *v 17460 } 17461 17462 for key, value := range shape { 17463 switch key { 17464 case "stylePassthrough": 17465 if value != nil { 17466 jtv, ok := value.(string) 17467 if !ok { 17468 return fmt.Errorf("expected TtmlStylePassthrough to be of type string, got %T instead", value) 17469 } 17470 sv.StylePassthrough = types.TtmlStylePassthrough(jtv) 17471 } 17472 17473 default: 17474 _, _ = key, value 17475 17476 } 17477 } 17478 *v = sv 17479 return nil 17480} 17481 17482func awsRestjson1_deserializeDocumentVc3Settings(v **types.Vc3Settings, value interface{}) error { 17483 if v == nil { 17484 return fmt.Errorf("unexpected nil of type %T", v) 17485 } 17486 if value == nil { 17487 return nil 17488 } 17489 17490 shape, ok := value.(map[string]interface{}) 17491 if !ok { 17492 return fmt.Errorf("unexpected JSON type %v", value) 17493 } 17494 17495 var sv *types.Vc3Settings 17496 if *v == nil { 17497 sv = &types.Vc3Settings{} 17498 } else { 17499 sv = *v 17500 } 17501 17502 for key, value := range shape { 17503 switch key { 17504 case "framerateControl": 17505 if value != nil { 17506 jtv, ok := value.(string) 17507 if !ok { 17508 return fmt.Errorf("expected Vc3FramerateControl to be of type string, got %T instead", value) 17509 } 17510 sv.FramerateControl = types.Vc3FramerateControl(jtv) 17511 } 17512 17513 case "framerateConversionAlgorithm": 17514 if value != nil { 17515 jtv, ok := value.(string) 17516 if !ok { 17517 return fmt.Errorf("expected Vc3FramerateConversionAlgorithm to be of type string, got %T instead", value) 17518 } 17519 sv.FramerateConversionAlgorithm = types.Vc3FramerateConversionAlgorithm(jtv) 17520 } 17521 17522 case "framerateDenominator": 17523 if value != nil { 17524 jtv, ok := value.(json.Number) 17525 if !ok { 17526 return fmt.Errorf("expected __integerMin1Max1001 to be json.Number, got %T instead", value) 17527 } 17528 i64, err := jtv.Int64() 17529 if err != nil { 17530 return err 17531 } 17532 sv.FramerateDenominator = int32(i64) 17533 } 17534 17535 case "framerateNumerator": 17536 if value != nil { 17537 jtv, ok := value.(json.Number) 17538 if !ok { 17539 return fmt.Errorf("expected __integerMin24Max60000 to be json.Number, got %T instead", value) 17540 } 17541 i64, err := jtv.Int64() 17542 if err != nil { 17543 return err 17544 } 17545 sv.FramerateNumerator = int32(i64) 17546 } 17547 17548 case "interlaceMode": 17549 if value != nil { 17550 jtv, ok := value.(string) 17551 if !ok { 17552 return fmt.Errorf("expected Vc3InterlaceMode to be of type string, got %T instead", value) 17553 } 17554 sv.InterlaceMode = types.Vc3InterlaceMode(jtv) 17555 } 17556 17557 case "slowPal": 17558 if value != nil { 17559 jtv, ok := value.(string) 17560 if !ok { 17561 return fmt.Errorf("expected Vc3SlowPal to be of type string, got %T instead", value) 17562 } 17563 sv.SlowPal = types.Vc3SlowPal(jtv) 17564 } 17565 17566 case "telecine": 17567 if value != nil { 17568 jtv, ok := value.(string) 17569 if !ok { 17570 return fmt.Errorf("expected Vc3Telecine to be of type string, got %T instead", value) 17571 } 17572 sv.Telecine = types.Vc3Telecine(jtv) 17573 } 17574 17575 case "vc3Class": 17576 if value != nil { 17577 jtv, ok := value.(string) 17578 if !ok { 17579 return fmt.Errorf("expected Vc3Class to be of type string, got %T instead", value) 17580 } 17581 sv.Vc3Class = types.Vc3Class(jtv) 17582 } 17583 17584 default: 17585 _, _ = key, value 17586 17587 } 17588 } 17589 *v = sv 17590 return nil 17591} 17592 17593func awsRestjson1_deserializeDocumentVideoCodecSettings(v **types.VideoCodecSettings, value interface{}) error { 17594 if v == nil { 17595 return fmt.Errorf("unexpected nil of type %T", v) 17596 } 17597 if value == nil { 17598 return nil 17599 } 17600 17601 shape, ok := value.(map[string]interface{}) 17602 if !ok { 17603 return fmt.Errorf("unexpected JSON type %v", value) 17604 } 17605 17606 var sv *types.VideoCodecSettings 17607 if *v == nil { 17608 sv = &types.VideoCodecSettings{} 17609 } else { 17610 sv = *v 17611 } 17612 17613 for key, value := range shape { 17614 switch key { 17615 case "av1Settings": 17616 if err := awsRestjson1_deserializeDocumentAv1Settings(&sv.Av1Settings, value); err != nil { 17617 return err 17618 } 17619 17620 case "avcIntraSettings": 17621 if err := awsRestjson1_deserializeDocumentAvcIntraSettings(&sv.AvcIntraSettings, value); err != nil { 17622 return err 17623 } 17624 17625 case "codec": 17626 if value != nil { 17627 jtv, ok := value.(string) 17628 if !ok { 17629 return fmt.Errorf("expected VideoCodec to be of type string, got %T instead", value) 17630 } 17631 sv.Codec = types.VideoCodec(jtv) 17632 } 17633 17634 case "frameCaptureSettings": 17635 if err := awsRestjson1_deserializeDocumentFrameCaptureSettings(&sv.FrameCaptureSettings, value); err != nil { 17636 return err 17637 } 17638 17639 case "h264Settings": 17640 if err := awsRestjson1_deserializeDocumentH264Settings(&sv.H264Settings, value); err != nil { 17641 return err 17642 } 17643 17644 case "h265Settings": 17645 if err := awsRestjson1_deserializeDocumentH265Settings(&sv.H265Settings, value); err != nil { 17646 return err 17647 } 17648 17649 case "mpeg2Settings": 17650 if err := awsRestjson1_deserializeDocumentMpeg2Settings(&sv.Mpeg2Settings, value); err != nil { 17651 return err 17652 } 17653 17654 case "proresSettings": 17655 if err := awsRestjson1_deserializeDocumentProresSettings(&sv.ProresSettings, value); err != nil { 17656 return err 17657 } 17658 17659 case "vc3Settings": 17660 if err := awsRestjson1_deserializeDocumentVc3Settings(&sv.Vc3Settings, value); err != nil { 17661 return err 17662 } 17663 17664 case "vp8Settings": 17665 if err := awsRestjson1_deserializeDocumentVp8Settings(&sv.Vp8Settings, value); err != nil { 17666 return err 17667 } 17668 17669 case "vp9Settings": 17670 if err := awsRestjson1_deserializeDocumentVp9Settings(&sv.Vp9Settings, value); err != nil { 17671 return err 17672 } 17673 17674 default: 17675 _, _ = key, value 17676 17677 } 17678 } 17679 *v = sv 17680 return nil 17681} 17682 17683func awsRestjson1_deserializeDocumentVideoDescription(v **types.VideoDescription, value interface{}) error { 17684 if v == nil { 17685 return fmt.Errorf("unexpected nil of type %T", v) 17686 } 17687 if value == nil { 17688 return nil 17689 } 17690 17691 shape, ok := value.(map[string]interface{}) 17692 if !ok { 17693 return fmt.Errorf("unexpected JSON type %v", value) 17694 } 17695 17696 var sv *types.VideoDescription 17697 if *v == nil { 17698 sv = &types.VideoDescription{} 17699 } else { 17700 sv = *v 17701 } 17702 17703 for key, value := range shape { 17704 switch key { 17705 case "afdSignaling": 17706 if value != nil { 17707 jtv, ok := value.(string) 17708 if !ok { 17709 return fmt.Errorf("expected AfdSignaling to be of type string, got %T instead", value) 17710 } 17711 sv.AfdSignaling = types.AfdSignaling(jtv) 17712 } 17713 17714 case "antiAlias": 17715 if value != nil { 17716 jtv, ok := value.(string) 17717 if !ok { 17718 return fmt.Errorf("expected AntiAlias to be of type string, got %T instead", value) 17719 } 17720 sv.AntiAlias = types.AntiAlias(jtv) 17721 } 17722 17723 case "codecSettings": 17724 if err := awsRestjson1_deserializeDocumentVideoCodecSettings(&sv.CodecSettings, value); err != nil { 17725 return err 17726 } 17727 17728 case "colorMetadata": 17729 if value != nil { 17730 jtv, ok := value.(string) 17731 if !ok { 17732 return fmt.Errorf("expected ColorMetadata to be of type string, got %T instead", value) 17733 } 17734 sv.ColorMetadata = types.ColorMetadata(jtv) 17735 } 17736 17737 case "crop": 17738 if err := awsRestjson1_deserializeDocumentRectangle(&sv.Crop, value); err != nil { 17739 return err 17740 } 17741 17742 case "dropFrameTimecode": 17743 if value != nil { 17744 jtv, ok := value.(string) 17745 if !ok { 17746 return fmt.Errorf("expected DropFrameTimecode to be of type string, got %T instead", value) 17747 } 17748 sv.DropFrameTimecode = types.DropFrameTimecode(jtv) 17749 } 17750 17751 case "fixedAfd": 17752 if value != nil { 17753 jtv, ok := value.(json.Number) 17754 if !ok { 17755 return fmt.Errorf("expected __integerMin0Max15 to be json.Number, got %T instead", value) 17756 } 17757 i64, err := jtv.Int64() 17758 if err != nil { 17759 return err 17760 } 17761 sv.FixedAfd = int32(i64) 17762 } 17763 17764 case "height": 17765 if value != nil { 17766 jtv, ok := value.(json.Number) 17767 if !ok { 17768 return fmt.Errorf("expected __integerMin32Max8192 to be json.Number, got %T instead", value) 17769 } 17770 i64, err := jtv.Int64() 17771 if err != nil { 17772 return err 17773 } 17774 sv.Height = int32(i64) 17775 } 17776 17777 case "position": 17778 if err := awsRestjson1_deserializeDocumentRectangle(&sv.Position, value); err != nil { 17779 return err 17780 } 17781 17782 case "respondToAfd": 17783 if value != nil { 17784 jtv, ok := value.(string) 17785 if !ok { 17786 return fmt.Errorf("expected RespondToAfd to be of type string, got %T instead", value) 17787 } 17788 sv.RespondToAfd = types.RespondToAfd(jtv) 17789 } 17790 17791 case "scalingBehavior": 17792 if value != nil { 17793 jtv, ok := value.(string) 17794 if !ok { 17795 return fmt.Errorf("expected ScalingBehavior to be of type string, got %T instead", value) 17796 } 17797 sv.ScalingBehavior = types.ScalingBehavior(jtv) 17798 } 17799 17800 case "sharpness": 17801 if value != nil { 17802 jtv, ok := value.(json.Number) 17803 if !ok { 17804 return fmt.Errorf("expected __integerMin0Max100 to be json.Number, got %T instead", value) 17805 } 17806 i64, err := jtv.Int64() 17807 if err != nil { 17808 return err 17809 } 17810 sv.Sharpness = int32(i64) 17811 } 17812 17813 case "timecodeInsertion": 17814 if value != nil { 17815 jtv, ok := value.(string) 17816 if !ok { 17817 return fmt.Errorf("expected VideoTimecodeInsertion to be of type string, got %T instead", value) 17818 } 17819 sv.TimecodeInsertion = types.VideoTimecodeInsertion(jtv) 17820 } 17821 17822 case "videoPreprocessors": 17823 if err := awsRestjson1_deserializeDocumentVideoPreprocessor(&sv.VideoPreprocessors, value); err != nil { 17824 return err 17825 } 17826 17827 case "width": 17828 if value != nil { 17829 jtv, ok := value.(json.Number) 17830 if !ok { 17831 return fmt.Errorf("expected __integerMin32Max8192 to be json.Number, got %T instead", value) 17832 } 17833 i64, err := jtv.Int64() 17834 if err != nil { 17835 return err 17836 } 17837 sv.Width = int32(i64) 17838 } 17839 17840 default: 17841 _, _ = key, value 17842 17843 } 17844 } 17845 *v = sv 17846 return nil 17847} 17848 17849func awsRestjson1_deserializeDocumentVideoDetail(v **types.VideoDetail, value interface{}) error { 17850 if v == nil { 17851 return fmt.Errorf("unexpected nil of type %T", v) 17852 } 17853 if value == nil { 17854 return nil 17855 } 17856 17857 shape, ok := value.(map[string]interface{}) 17858 if !ok { 17859 return fmt.Errorf("unexpected JSON type %v", value) 17860 } 17861 17862 var sv *types.VideoDetail 17863 if *v == nil { 17864 sv = &types.VideoDetail{} 17865 } else { 17866 sv = *v 17867 } 17868 17869 for key, value := range shape { 17870 switch key { 17871 case "heightInPx": 17872 if value != nil { 17873 jtv, ok := value.(json.Number) 17874 if !ok { 17875 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 17876 } 17877 i64, err := jtv.Int64() 17878 if err != nil { 17879 return err 17880 } 17881 sv.HeightInPx = int32(i64) 17882 } 17883 17884 case "widthInPx": 17885 if value != nil { 17886 jtv, ok := value.(json.Number) 17887 if !ok { 17888 return fmt.Errorf("expected __integer to be json.Number, got %T instead", value) 17889 } 17890 i64, err := jtv.Int64() 17891 if err != nil { 17892 return err 17893 } 17894 sv.WidthInPx = int32(i64) 17895 } 17896 17897 default: 17898 _, _ = key, value 17899 17900 } 17901 } 17902 *v = sv 17903 return nil 17904} 17905 17906func awsRestjson1_deserializeDocumentVideoPreprocessor(v **types.VideoPreprocessor, value interface{}) error { 17907 if v == nil { 17908 return fmt.Errorf("unexpected nil of type %T", v) 17909 } 17910 if value == nil { 17911 return nil 17912 } 17913 17914 shape, ok := value.(map[string]interface{}) 17915 if !ok { 17916 return fmt.Errorf("unexpected JSON type %v", value) 17917 } 17918 17919 var sv *types.VideoPreprocessor 17920 if *v == nil { 17921 sv = &types.VideoPreprocessor{} 17922 } else { 17923 sv = *v 17924 } 17925 17926 for key, value := range shape { 17927 switch key { 17928 case "colorCorrector": 17929 if err := awsRestjson1_deserializeDocumentColorCorrector(&sv.ColorCorrector, value); err != nil { 17930 return err 17931 } 17932 17933 case "deinterlacer": 17934 if err := awsRestjson1_deserializeDocumentDeinterlacer(&sv.Deinterlacer, value); err != nil { 17935 return err 17936 } 17937 17938 case "dolbyVision": 17939 if err := awsRestjson1_deserializeDocumentDolbyVision(&sv.DolbyVision, value); err != nil { 17940 return err 17941 } 17942 17943 case "imageInserter": 17944 if err := awsRestjson1_deserializeDocumentImageInserter(&sv.ImageInserter, value); err != nil { 17945 return err 17946 } 17947 17948 case "noiseReducer": 17949 if err := awsRestjson1_deserializeDocumentNoiseReducer(&sv.NoiseReducer, value); err != nil { 17950 return err 17951 } 17952 17953 case "partnerWatermarking": 17954 if err := awsRestjson1_deserializeDocumentPartnerWatermarking(&sv.PartnerWatermarking, value); err != nil { 17955 return err 17956 } 17957 17958 case "timecodeBurnin": 17959 if err := awsRestjson1_deserializeDocumentTimecodeBurnin(&sv.TimecodeBurnin, value); err != nil { 17960 return err 17961 } 17962 17963 default: 17964 _, _ = key, value 17965 17966 } 17967 } 17968 *v = sv 17969 return nil 17970} 17971 17972func awsRestjson1_deserializeDocumentVideoSelector(v **types.VideoSelector, value interface{}) error { 17973 if v == nil { 17974 return fmt.Errorf("unexpected nil of type %T", v) 17975 } 17976 if value == nil { 17977 return nil 17978 } 17979 17980 shape, ok := value.(map[string]interface{}) 17981 if !ok { 17982 return fmt.Errorf("unexpected JSON type %v", value) 17983 } 17984 17985 var sv *types.VideoSelector 17986 if *v == nil { 17987 sv = &types.VideoSelector{} 17988 } else { 17989 sv = *v 17990 } 17991 17992 for key, value := range shape { 17993 switch key { 17994 case "alphaBehavior": 17995 if value != nil { 17996 jtv, ok := value.(string) 17997 if !ok { 17998 return fmt.Errorf("expected AlphaBehavior to be of type string, got %T instead", value) 17999 } 18000 sv.AlphaBehavior = types.AlphaBehavior(jtv) 18001 } 18002 18003 case "colorSpace": 18004 if value != nil { 18005 jtv, ok := value.(string) 18006 if !ok { 18007 return fmt.Errorf("expected ColorSpace to be of type string, got %T instead", value) 18008 } 18009 sv.ColorSpace = types.ColorSpace(jtv) 18010 } 18011 18012 case "colorSpaceUsage": 18013 if value != nil { 18014 jtv, ok := value.(string) 18015 if !ok { 18016 return fmt.Errorf("expected ColorSpaceUsage to be of type string, got %T instead", value) 18017 } 18018 sv.ColorSpaceUsage = types.ColorSpaceUsage(jtv) 18019 } 18020 18021 case "hdr10Metadata": 18022 if err := awsRestjson1_deserializeDocumentHdr10Metadata(&sv.Hdr10Metadata, value); err != nil { 18023 return err 18024 } 18025 18026 case "pid": 18027 if value != nil { 18028 jtv, ok := value.(json.Number) 18029 if !ok { 18030 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 18031 } 18032 i64, err := jtv.Int64() 18033 if err != nil { 18034 return err 18035 } 18036 sv.Pid = int32(i64) 18037 } 18038 18039 case "programNumber": 18040 if value != nil { 18041 jtv, ok := value.(json.Number) 18042 if !ok { 18043 return fmt.Errorf("expected __integerMinNegative2147483648Max2147483647 to be json.Number, got %T instead", value) 18044 } 18045 i64, err := jtv.Int64() 18046 if err != nil { 18047 return err 18048 } 18049 sv.ProgramNumber = int32(i64) 18050 } 18051 18052 case "rotate": 18053 if value != nil { 18054 jtv, ok := value.(string) 18055 if !ok { 18056 return fmt.Errorf("expected InputRotate to be of type string, got %T instead", value) 18057 } 18058 sv.Rotate = types.InputRotate(jtv) 18059 } 18060 18061 default: 18062 _, _ = key, value 18063 18064 } 18065 } 18066 *v = sv 18067 return nil 18068} 18069 18070func awsRestjson1_deserializeDocumentVorbisSettings(v **types.VorbisSettings, value interface{}) error { 18071 if v == nil { 18072 return fmt.Errorf("unexpected nil of type %T", v) 18073 } 18074 if value == nil { 18075 return nil 18076 } 18077 18078 shape, ok := value.(map[string]interface{}) 18079 if !ok { 18080 return fmt.Errorf("unexpected JSON type %v", value) 18081 } 18082 18083 var sv *types.VorbisSettings 18084 if *v == nil { 18085 sv = &types.VorbisSettings{} 18086 } else { 18087 sv = *v 18088 } 18089 18090 for key, value := range shape { 18091 switch key { 18092 case "channels": 18093 if value != nil { 18094 jtv, ok := value.(json.Number) 18095 if !ok { 18096 return fmt.Errorf("expected __integerMin1Max2 to be json.Number, got %T instead", value) 18097 } 18098 i64, err := jtv.Int64() 18099 if err != nil { 18100 return err 18101 } 18102 sv.Channels = int32(i64) 18103 } 18104 18105 case "sampleRate": 18106 if value != nil { 18107 jtv, ok := value.(json.Number) 18108 if !ok { 18109 return fmt.Errorf("expected __integerMin22050Max48000 to be json.Number, got %T instead", value) 18110 } 18111 i64, err := jtv.Int64() 18112 if err != nil { 18113 return err 18114 } 18115 sv.SampleRate = int32(i64) 18116 } 18117 18118 case "vbrQuality": 18119 if value != nil { 18120 jtv, ok := value.(json.Number) 18121 if !ok { 18122 return fmt.Errorf("expected __integerMinNegative1Max10 to be json.Number, got %T instead", value) 18123 } 18124 i64, err := jtv.Int64() 18125 if err != nil { 18126 return err 18127 } 18128 sv.VbrQuality = int32(i64) 18129 } 18130 18131 default: 18132 _, _ = key, value 18133 18134 } 18135 } 18136 *v = sv 18137 return nil 18138} 18139 18140func awsRestjson1_deserializeDocumentVp8Settings(v **types.Vp8Settings, value interface{}) error { 18141 if v == nil { 18142 return fmt.Errorf("unexpected nil of type %T", v) 18143 } 18144 if value == nil { 18145 return nil 18146 } 18147 18148 shape, ok := value.(map[string]interface{}) 18149 if !ok { 18150 return fmt.Errorf("unexpected JSON type %v", value) 18151 } 18152 18153 var sv *types.Vp8Settings 18154 if *v == nil { 18155 sv = &types.Vp8Settings{} 18156 } else { 18157 sv = *v 18158 } 18159 18160 for key, value := range shape { 18161 switch key { 18162 case "bitrate": 18163 if value != nil { 18164 jtv, ok := value.(json.Number) 18165 if !ok { 18166 return fmt.Errorf("expected __integerMin1000Max1152000000 to be json.Number, got %T instead", value) 18167 } 18168 i64, err := jtv.Int64() 18169 if err != nil { 18170 return err 18171 } 18172 sv.Bitrate = int32(i64) 18173 } 18174 18175 case "framerateControl": 18176 if value != nil { 18177 jtv, ok := value.(string) 18178 if !ok { 18179 return fmt.Errorf("expected Vp8FramerateControl to be of type string, got %T instead", value) 18180 } 18181 sv.FramerateControl = types.Vp8FramerateControl(jtv) 18182 } 18183 18184 case "framerateConversionAlgorithm": 18185 if value != nil { 18186 jtv, ok := value.(string) 18187 if !ok { 18188 return fmt.Errorf("expected Vp8FramerateConversionAlgorithm to be of type string, got %T instead", value) 18189 } 18190 sv.FramerateConversionAlgorithm = types.Vp8FramerateConversionAlgorithm(jtv) 18191 } 18192 18193 case "framerateDenominator": 18194 if value != nil { 18195 jtv, ok := value.(json.Number) 18196 if !ok { 18197 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 18198 } 18199 i64, err := jtv.Int64() 18200 if err != nil { 18201 return err 18202 } 18203 sv.FramerateDenominator = int32(i64) 18204 } 18205 18206 case "framerateNumerator": 18207 if value != nil { 18208 jtv, ok := value.(json.Number) 18209 if !ok { 18210 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 18211 } 18212 i64, err := jtv.Int64() 18213 if err != nil { 18214 return err 18215 } 18216 sv.FramerateNumerator = int32(i64) 18217 } 18218 18219 case "gopSize": 18220 if value != nil { 18221 jtv, ok := value.(json.Number) 18222 if !ok { 18223 return fmt.Errorf("expected __doubleMin0 to be json.Number, got %T instead", value) 18224 } 18225 f64, err := jtv.Float64() 18226 if err != nil { 18227 return err 18228 } 18229 sv.GopSize = f64 18230 } 18231 18232 case "hrdBufferSize": 18233 if value != nil { 18234 jtv, ok := value.(json.Number) 18235 if !ok { 18236 return fmt.Errorf("expected __integerMin0Max47185920 to be json.Number, got %T instead", value) 18237 } 18238 i64, err := jtv.Int64() 18239 if err != nil { 18240 return err 18241 } 18242 sv.HrdBufferSize = int32(i64) 18243 } 18244 18245 case "maxBitrate": 18246 if value != nil { 18247 jtv, ok := value.(json.Number) 18248 if !ok { 18249 return fmt.Errorf("expected __integerMin1000Max1152000000 to be json.Number, got %T instead", value) 18250 } 18251 i64, err := jtv.Int64() 18252 if err != nil { 18253 return err 18254 } 18255 sv.MaxBitrate = int32(i64) 18256 } 18257 18258 case "parControl": 18259 if value != nil { 18260 jtv, ok := value.(string) 18261 if !ok { 18262 return fmt.Errorf("expected Vp8ParControl to be of type string, got %T instead", value) 18263 } 18264 sv.ParControl = types.Vp8ParControl(jtv) 18265 } 18266 18267 case "parDenominator": 18268 if value != nil { 18269 jtv, ok := value.(json.Number) 18270 if !ok { 18271 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 18272 } 18273 i64, err := jtv.Int64() 18274 if err != nil { 18275 return err 18276 } 18277 sv.ParDenominator = int32(i64) 18278 } 18279 18280 case "parNumerator": 18281 if value != nil { 18282 jtv, ok := value.(json.Number) 18283 if !ok { 18284 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 18285 } 18286 i64, err := jtv.Int64() 18287 if err != nil { 18288 return err 18289 } 18290 sv.ParNumerator = int32(i64) 18291 } 18292 18293 case "qualityTuningLevel": 18294 if value != nil { 18295 jtv, ok := value.(string) 18296 if !ok { 18297 return fmt.Errorf("expected Vp8QualityTuningLevel to be of type string, got %T instead", value) 18298 } 18299 sv.QualityTuningLevel = types.Vp8QualityTuningLevel(jtv) 18300 } 18301 18302 case "rateControlMode": 18303 if value != nil { 18304 jtv, ok := value.(string) 18305 if !ok { 18306 return fmt.Errorf("expected Vp8RateControlMode to be of type string, got %T instead", value) 18307 } 18308 sv.RateControlMode = types.Vp8RateControlMode(jtv) 18309 } 18310 18311 default: 18312 _, _ = key, value 18313 18314 } 18315 } 18316 *v = sv 18317 return nil 18318} 18319 18320func awsRestjson1_deserializeDocumentVp9Settings(v **types.Vp9Settings, value interface{}) error { 18321 if v == nil { 18322 return fmt.Errorf("unexpected nil of type %T", v) 18323 } 18324 if value == nil { 18325 return nil 18326 } 18327 18328 shape, ok := value.(map[string]interface{}) 18329 if !ok { 18330 return fmt.Errorf("unexpected JSON type %v", value) 18331 } 18332 18333 var sv *types.Vp9Settings 18334 if *v == nil { 18335 sv = &types.Vp9Settings{} 18336 } else { 18337 sv = *v 18338 } 18339 18340 for key, value := range shape { 18341 switch key { 18342 case "bitrate": 18343 if value != nil { 18344 jtv, ok := value.(json.Number) 18345 if !ok { 18346 return fmt.Errorf("expected __integerMin1000Max480000000 to be json.Number, got %T instead", value) 18347 } 18348 i64, err := jtv.Int64() 18349 if err != nil { 18350 return err 18351 } 18352 sv.Bitrate = int32(i64) 18353 } 18354 18355 case "framerateControl": 18356 if value != nil { 18357 jtv, ok := value.(string) 18358 if !ok { 18359 return fmt.Errorf("expected Vp9FramerateControl to be of type string, got %T instead", value) 18360 } 18361 sv.FramerateControl = types.Vp9FramerateControl(jtv) 18362 } 18363 18364 case "framerateConversionAlgorithm": 18365 if value != nil { 18366 jtv, ok := value.(string) 18367 if !ok { 18368 return fmt.Errorf("expected Vp9FramerateConversionAlgorithm to be of type string, got %T instead", value) 18369 } 18370 sv.FramerateConversionAlgorithm = types.Vp9FramerateConversionAlgorithm(jtv) 18371 } 18372 18373 case "framerateDenominator": 18374 if value != nil { 18375 jtv, ok := value.(json.Number) 18376 if !ok { 18377 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 18378 } 18379 i64, err := jtv.Int64() 18380 if err != nil { 18381 return err 18382 } 18383 sv.FramerateDenominator = int32(i64) 18384 } 18385 18386 case "framerateNumerator": 18387 if value != nil { 18388 jtv, ok := value.(json.Number) 18389 if !ok { 18390 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 18391 } 18392 i64, err := jtv.Int64() 18393 if err != nil { 18394 return err 18395 } 18396 sv.FramerateNumerator = int32(i64) 18397 } 18398 18399 case "gopSize": 18400 if value != nil { 18401 jtv, ok := value.(json.Number) 18402 if !ok { 18403 return fmt.Errorf("expected __doubleMin0 to be json.Number, got %T instead", value) 18404 } 18405 f64, err := jtv.Float64() 18406 if err != nil { 18407 return err 18408 } 18409 sv.GopSize = f64 18410 } 18411 18412 case "hrdBufferSize": 18413 if value != nil { 18414 jtv, ok := value.(json.Number) 18415 if !ok { 18416 return fmt.Errorf("expected __integerMin0Max47185920 to be json.Number, got %T instead", value) 18417 } 18418 i64, err := jtv.Int64() 18419 if err != nil { 18420 return err 18421 } 18422 sv.HrdBufferSize = int32(i64) 18423 } 18424 18425 case "maxBitrate": 18426 if value != nil { 18427 jtv, ok := value.(json.Number) 18428 if !ok { 18429 return fmt.Errorf("expected __integerMin1000Max480000000 to be json.Number, got %T instead", value) 18430 } 18431 i64, err := jtv.Int64() 18432 if err != nil { 18433 return err 18434 } 18435 sv.MaxBitrate = int32(i64) 18436 } 18437 18438 case "parControl": 18439 if value != nil { 18440 jtv, ok := value.(string) 18441 if !ok { 18442 return fmt.Errorf("expected Vp9ParControl to be of type string, got %T instead", value) 18443 } 18444 sv.ParControl = types.Vp9ParControl(jtv) 18445 } 18446 18447 case "parDenominator": 18448 if value != nil { 18449 jtv, ok := value.(json.Number) 18450 if !ok { 18451 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 18452 } 18453 i64, err := jtv.Int64() 18454 if err != nil { 18455 return err 18456 } 18457 sv.ParDenominator = int32(i64) 18458 } 18459 18460 case "parNumerator": 18461 if value != nil { 18462 jtv, ok := value.(json.Number) 18463 if !ok { 18464 return fmt.Errorf("expected __integerMin1Max2147483647 to be json.Number, got %T instead", value) 18465 } 18466 i64, err := jtv.Int64() 18467 if err != nil { 18468 return err 18469 } 18470 sv.ParNumerator = int32(i64) 18471 } 18472 18473 case "qualityTuningLevel": 18474 if value != nil { 18475 jtv, ok := value.(string) 18476 if !ok { 18477 return fmt.Errorf("expected Vp9QualityTuningLevel to be of type string, got %T instead", value) 18478 } 18479 sv.QualityTuningLevel = types.Vp9QualityTuningLevel(jtv) 18480 } 18481 18482 case "rateControlMode": 18483 if value != nil { 18484 jtv, ok := value.(string) 18485 if !ok { 18486 return fmt.Errorf("expected Vp9RateControlMode to be of type string, got %T instead", value) 18487 } 18488 sv.RateControlMode = types.Vp9RateControlMode(jtv) 18489 } 18490 18491 default: 18492 _, _ = key, value 18493 18494 } 18495 } 18496 *v = sv 18497 return nil 18498} 18499 18500func awsRestjson1_deserializeDocumentWavSettings(v **types.WavSettings, value interface{}) error { 18501 if v == nil { 18502 return fmt.Errorf("unexpected nil of type %T", v) 18503 } 18504 if value == nil { 18505 return nil 18506 } 18507 18508 shape, ok := value.(map[string]interface{}) 18509 if !ok { 18510 return fmt.Errorf("unexpected JSON type %v", value) 18511 } 18512 18513 var sv *types.WavSettings 18514 if *v == nil { 18515 sv = &types.WavSettings{} 18516 } else { 18517 sv = *v 18518 } 18519 18520 for key, value := range shape { 18521 switch key { 18522 case "bitDepth": 18523 if value != nil { 18524 jtv, ok := value.(json.Number) 18525 if !ok { 18526 return fmt.Errorf("expected __integerMin16Max24 to be json.Number, got %T instead", value) 18527 } 18528 i64, err := jtv.Int64() 18529 if err != nil { 18530 return err 18531 } 18532 sv.BitDepth = int32(i64) 18533 } 18534 18535 case "channels": 18536 if value != nil { 18537 jtv, ok := value.(json.Number) 18538 if !ok { 18539 return fmt.Errorf("expected __integerMin1Max64 to be json.Number, got %T instead", value) 18540 } 18541 i64, err := jtv.Int64() 18542 if err != nil { 18543 return err 18544 } 18545 sv.Channels = int32(i64) 18546 } 18547 18548 case "format": 18549 if value != nil { 18550 jtv, ok := value.(string) 18551 if !ok { 18552 return fmt.Errorf("expected WavFormat to be of type string, got %T instead", value) 18553 } 18554 sv.Format = types.WavFormat(jtv) 18555 } 18556 18557 case "sampleRate": 18558 if value != nil { 18559 jtv, ok := value.(json.Number) 18560 if !ok { 18561 return fmt.Errorf("expected __integerMin8000Max192000 to be json.Number, got %T instead", value) 18562 } 18563 i64, err := jtv.Int64() 18564 if err != nil { 18565 return err 18566 } 18567 sv.SampleRate = int32(i64) 18568 } 18569 18570 default: 18571 _, _ = key, value 18572 18573 } 18574 } 18575 *v = sv 18576 return nil 18577} 18578