1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package transcribe 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/transcribe/types" 12 smithy "github.com/aws/smithy-go" 13 smithyio "github.com/aws/smithy-go/io" 14 "github.com/aws/smithy-go/middleware" 15 "github.com/aws/smithy-go/ptr" 16 smithytime "github.com/aws/smithy-go/time" 17 smithyhttp "github.com/aws/smithy-go/transport/http" 18 "io" 19 "io/ioutil" 20 "strings" 21) 22 23type awsAwsjson11_deserializeOpCreateLanguageModel struct { 24} 25 26func (*awsAwsjson11_deserializeOpCreateLanguageModel) ID() string { 27 return "OperationDeserializer" 28} 29 30func (m *awsAwsjson11_deserializeOpCreateLanguageModel) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 31 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 32) { 33 out, metadata, err = next.HandleDeserialize(ctx, in) 34 if err != nil { 35 return out, metadata, err 36 } 37 38 response, ok := out.RawResponse.(*smithyhttp.Response) 39 if !ok { 40 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 41 } 42 43 if response.StatusCode < 200 || response.StatusCode >= 300 { 44 return out, metadata, awsAwsjson11_deserializeOpErrorCreateLanguageModel(response, &metadata) 45 } 46 output := &CreateLanguageModelOutput{} 47 out.Result = output 48 49 var buff [1024]byte 50 ringBuffer := smithyio.NewRingBuffer(buff[:]) 51 52 body := io.TeeReader(response.Body, ringBuffer) 53 decoder := json.NewDecoder(body) 54 decoder.UseNumber() 55 var shape interface{} 56 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 57 var snapshot bytes.Buffer 58 io.Copy(&snapshot, ringBuffer) 59 err = &smithy.DeserializationError{ 60 Err: fmt.Errorf("failed to decode response body, %w", err), 61 Snapshot: snapshot.Bytes(), 62 } 63 return out, metadata, err 64 } 65 66 err = awsAwsjson11_deserializeOpDocumentCreateLanguageModelOutput(&output, shape) 67 if err != nil { 68 var snapshot bytes.Buffer 69 io.Copy(&snapshot, ringBuffer) 70 err = &smithy.DeserializationError{ 71 Err: fmt.Errorf("failed to decode response body, %w", err), 72 Snapshot: snapshot.Bytes(), 73 } 74 return out, metadata, err 75 } 76 77 return out, metadata, err 78} 79 80func awsAwsjson11_deserializeOpErrorCreateLanguageModel(response *smithyhttp.Response, metadata *middleware.Metadata) error { 81 var errorBuffer bytes.Buffer 82 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 83 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 84 } 85 errorBody := bytes.NewReader(errorBuffer.Bytes()) 86 87 errorCode := "UnknownError" 88 errorMessage := errorCode 89 90 code := response.Header.Get("X-Amzn-ErrorType") 91 if len(code) != 0 { 92 errorCode = restjson.SanitizeErrorCode(code) 93 } 94 95 var buff [1024]byte 96 ringBuffer := smithyio.NewRingBuffer(buff[:]) 97 98 body := io.TeeReader(errorBody, ringBuffer) 99 decoder := json.NewDecoder(body) 100 decoder.UseNumber() 101 code, message, err := restjson.GetErrorInfo(decoder) 102 if err != nil { 103 var snapshot bytes.Buffer 104 io.Copy(&snapshot, ringBuffer) 105 err = &smithy.DeserializationError{ 106 Err: fmt.Errorf("failed to decode response body, %w", err), 107 Snapshot: snapshot.Bytes(), 108 } 109 return err 110 } 111 112 errorBody.Seek(0, io.SeekStart) 113 if len(code) != 0 { 114 errorCode = restjson.SanitizeErrorCode(code) 115 } 116 if len(message) != 0 { 117 errorMessage = message 118 } 119 120 switch { 121 case strings.EqualFold("BadRequestException", errorCode): 122 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 123 124 case strings.EqualFold("ConflictException", errorCode): 125 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 126 127 case strings.EqualFold("InternalFailureException", errorCode): 128 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 129 130 case strings.EqualFold("LimitExceededException", errorCode): 131 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 132 133 default: 134 genericError := &smithy.GenericAPIError{ 135 Code: errorCode, 136 Message: errorMessage, 137 } 138 return genericError 139 140 } 141} 142 143type awsAwsjson11_deserializeOpCreateMedicalVocabulary struct { 144} 145 146func (*awsAwsjson11_deserializeOpCreateMedicalVocabulary) ID() string { 147 return "OperationDeserializer" 148} 149 150func (m *awsAwsjson11_deserializeOpCreateMedicalVocabulary) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 151 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 152) { 153 out, metadata, err = next.HandleDeserialize(ctx, in) 154 if err != nil { 155 return out, metadata, err 156 } 157 158 response, ok := out.RawResponse.(*smithyhttp.Response) 159 if !ok { 160 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 161 } 162 163 if response.StatusCode < 200 || response.StatusCode >= 300 { 164 return out, metadata, awsAwsjson11_deserializeOpErrorCreateMedicalVocabulary(response, &metadata) 165 } 166 output := &CreateMedicalVocabularyOutput{} 167 out.Result = output 168 169 var buff [1024]byte 170 ringBuffer := smithyio.NewRingBuffer(buff[:]) 171 172 body := io.TeeReader(response.Body, ringBuffer) 173 decoder := json.NewDecoder(body) 174 decoder.UseNumber() 175 var shape interface{} 176 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 177 var snapshot bytes.Buffer 178 io.Copy(&snapshot, ringBuffer) 179 err = &smithy.DeserializationError{ 180 Err: fmt.Errorf("failed to decode response body, %w", err), 181 Snapshot: snapshot.Bytes(), 182 } 183 return out, metadata, err 184 } 185 186 err = awsAwsjson11_deserializeOpDocumentCreateMedicalVocabularyOutput(&output, shape) 187 if err != nil { 188 var snapshot bytes.Buffer 189 io.Copy(&snapshot, ringBuffer) 190 err = &smithy.DeserializationError{ 191 Err: fmt.Errorf("failed to decode response body, %w", err), 192 Snapshot: snapshot.Bytes(), 193 } 194 return out, metadata, err 195 } 196 197 return out, metadata, err 198} 199 200func awsAwsjson11_deserializeOpErrorCreateMedicalVocabulary(response *smithyhttp.Response, metadata *middleware.Metadata) error { 201 var errorBuffer bytes.Buffer 202 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 203 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 204 } 205 errorBody := bytes.NewReader(errorBuffer.Bytes()) 206 207 errorCode := "UnknownError" 208 errorMessage := errorCode 209 210 code := response.Header.Get("X-Amzn-ErrorType") 211 if len(code) != 0 { 212 errorCode = restjson.SanitizeErrorCode(code) 213 } 214 215 var buff [1024]byte 216 ringBuffer := smithyio.NewRingBuffer(buff[:]) 217 218 body := io.TeeReader(errorBody, ringBuffer) 219 decoder := json.NewDecoder(body) 220 decoder.UseNumber() 221 code, message, err := restjson.GetErrorInfo(decoder) 222 if err != nil { 223 var snapshot bytes.Buffer 224 io.Copy(&snapshot, ringBuffer) 225 err = &smithy.DeserializationError{ 226 Err: fmt.Errorf("failed to decode response body, %w", err), 227 Snapshot: snapshot.Bytes(), 228 } 229 return err 230 } 231 232 errorBody.Seek(0, io.SeekStart) 233 if len(code) != 0 { 234 errorCode = restjson.SanitizeErrorCode(code) 235 } 236 if len(message) != 0 { 237 errorMessage = message 238 } 239 240 switch { 241 case strings.EqualFold("BadRequestException", errorCode): 242 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 243 244 case strings.EqualFold("ConflictException", errorCode): 245 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 246 247 case strings.EqualFold("InternalFailureException", errorCode): 248 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 249 250 case strings.EqualFold("LimitExceededException", errorCode): 251 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 252 253 default: 254 genericError := &smithy.GenericAPIError{ 255 Code: errorCode, 256 Message: errorMessage, 257 } 258 return genericError 259 260 } 261} 262 263type awsAwsjson11_deserializeOpCreateVocabulary struct { 264} 265 266func (*awsAwsjson11_deserializeOpCreateVocabulary) ID() string { 267 return "OperationDeserializer" 268} 269 270func (m *awsAwsjson11_deserializeOpCreateVocabulary) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 271 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 272) { 273 out, metadata, err = next.HandleDeserialize(ctx, in) 274 if err != nil { 275 return out, metadata, err 276 } 277 278 response, ok := out.RawResponse.(*smithyhttp.Response) 279 if !ok { 280 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 281 } 282 283 if response.StatusCode < 200 || response.StatusCode >= 300 { 284 return out, metadata, awsAwsjson11_deserializeOpErrorCreateVocabulary(response, &metadata) 285 } 286 output := &CreateVocabularyOutput{} 287 out.Result = output 288 289 var buff [1024]byte 290 ringBuffer := smithyio.NewRingBuffer(buff[:]) 291 292 body := io.TeeReader(response.Body, ringBuffer) 293 decoder := json.NewDecoder(body) 294 decoder.UseNumber() 295 var shape interface{} 296 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 297 var snapshot bytes.Buffer 298 io.Copy(&snapshot, ringBuffer) 299 err = &smithy.DeserializationError{ 300 Err: fmt.Errorf("failed to decode response body, %w", err), 301 Snapshot: snapshot.Bytes(), 302 } 303 return out, metadata, err 304 } 305 306 err = awsAwsjson11_deserializeOpDocumentCreateVocabularyOutput(&output, shape) 307 if err != nil { 308 var snapshot bytes.Buffer 309 io.Copy(&snapshot, ringBuffer) 310 err = &smithy.DeserializationError{ 311 Err: fmt.Errorf("failed to decode response body, %w", err), 312 Snapshot: snapshot.Bytes(), 313 } 314 return out, metadata, err 315 } 316 317 return out, metadata, err 318} 319 320func awsAwsjson11_deserializeOpErrorCreateVocabulary(response *smithyhttp.Response, metadata *middleware.Metadata) error { 321 var errorBuffer bytes.Buffer 322 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 323 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 324 } 325 errorBody := bytes.NewReader(errorBuffer.Bytes()) 326 327 errorCode := "UnknownError" 328 errorMessage := errorCode 329 330 code := response.Header.Get("X-Amzn-ErrorType") 331 if len(code) != 0 { 332 errorCode = restjson.SanitizeErrorCode(code) 333 } 334 335 var buff [1024]byte 336 ringBuffer := smithyio.NewRingBuffer(buff[:]) 337 338 body := io.TeeReader(errorBody, ringBuffer) 339 decoder := json.NewDecoder(body) 340 decoder.UseNumber() 341 code, message, err := restjson.GetErrorInfo(decoder) 342 if err != nil { 343 var snapshot bytes.Buffer 344 io.Copy(&snapshot, ringBuffer) 345 err = &smithy.DeserializationError{ 346 Err: fmt.Errorf("failed to decode response body, %w", err), 347 Snapshot: snapshot.Bytes(), 348 } 349 return err 350 } 351 352 errorBody.Seek(0, io.SeekStart) 353 if len(code) != 0 { 354 errorCode = restjson.SanitizeErrorCode(code) 355 } 356 if len(message) != 0 { 357 errorMessage = message 358 } 359 360 switch { 361 case strings.EqualFold("BadRequestException", errorCode): 362 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 363 364 case strings.EqualFold("ConflictException", errorCode): 365 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 366 367 case strings.EqualFold("InternalFailureException", errorCode): 368 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 369 370 case strings.EqualFold("LimitExceededException", errorCode): 371 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 372 373 default: 374 genericError := &smithy.GenericAPIError{ 375 Code: errorCode, 376 Message: errorMessage, 377 } 378 return genericError 379 380 } 381} 382 383type awsAwsjson11_deserializeOpCreateVocabularyFilter struct { 384} 385 386func (*awsAwsjson11_deserializeOpCreateVocabularyFilter) ID() string { 387 return "OperationDeserializer" 388} 389 390func (m *awsAwsjson11_deserializeOpCreateVocabularyFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 391 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 392) { 393 out, metadata, err = next.HandleDeserialize(ctx, in) 394 if err != nil { 395 return out, metadata, err 396 } 397 398 response, ok := out.RawResponse.(*smithyhttp.Response) 399 if !ok { 400 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 401 } 402 403 if response.StatusCode < 200 || response.StatusCode >= 300 { 404 return out, metadata, awsAwsjson11_deserializeOpErrorCreateVocabularyFilter(response, &metadata) 405 } 406 output := &CreateVocabularyFilterOutput{} 407 out.Result = output 408 409 var buff [1024]byte 410 ringBuffer := smithyio.NewRingBuffer(buff[:]) 411 412 body := io.TeeReader(response.Body, ringBuffer) 413 decoder := json.NewDecoder(body) 414 decoder.UseNumber() 415 var shape interface{} 416 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 417 var snapshot bytes.Buffer 418 io.Copy(&snapshot, ringBuffer) 419 err = &smithy.DeserializationError{ 420 Err: fmt.Errorf("failed to decode response body, %w", err), 421 Snapshot: snapshot.Bytes(), 422 } 423 return out, metadata, err 424 } 425 426 err = awsAwsjson11_deserializeOpDocumentCreateVocabularyFilterOutput(&output, shape) 427 if err != nil { 428 var snapshot bytes.Buffer 429 io.Copy(&snapshot, ringBuffer) 430 err = &smithy.DeserializationError{ 431 Err: fmt.Errorf("failed to decode response body, %w", err), 432 Snapshot: snapshot.Bytes(), 433 } 434 return out, metadata, err 435 } 436 437 return out, metadata, err 438} 439 440func awsAwsjson11_deserializeOpErrorCreateVocabularyFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 441 var errorBuffer bytes.Buffer 442 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 443 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 444 } 445 errorBody := bytes.NewReader(errorBuffer.Bytes()) 446 447 errorCode := "UnknownError" 448 errorMessage := errorCode 449 450 code := response.Header.Get("X-Amzn-ErrorType") 451 if len(code) != 0 { 452 errorCode = restjson.SanitizeErrorCode(code) 453 } 454 455 var buff [1024]byte 456 ringBuffer := smithyio.NewRingBuffer(buff[:]) 457 458 body := io.TeeReader(errorBody, ringBuffer) 459 decoder := json.NewDecoder(body) 460 decoder.UseNumber() 461 code, message, err := restjson.GetErrorInfo(decoder) 462 if err != nil { 463 var snapshot bytes.Buffer 464 io.Copy(&snapshot, ringBuffer) 465 err = &smithy.DeserializationError{ 466 Err: fmt.Errorf("failed to decode response body, %w", err), 467 Snapshot: snapshot.Bytes(), 468 } 469 return err 470 } 471 472 errorBody.Seek(0, io.SeekStart) 473 if len(code) != 0 { 474 errorCode = restjson.SanitizeErrorCode(code) 475 } 476 if len(message) != 0 { 477 errorMessage = message 478 } 479 480 switch { 481 case strings.EqualFold("BadRequestException", errorCode): 482 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 483 484 case strings.EqualFold("ConflictException", errorCode): 485 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 486 487 case strings.EqualFold("InternalFailureException", errorCode): 488 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 489 490 case strings.EqualFold("LimitExceededException", errorCode): 491 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 492 493 default: 494 genericError := &smithy.GenericAPIError{ 495 Code: errorCode, 496 Message: errorMessage, 497 } 498 return genericError 499 500 } 501} 502 503type awsAwsjson11_deserializeOpDeleteLanguageModel struct { 504} 505 506func (*awsAwsjson11_deserializeOpDeleteLanguageModel) ID() string { 507 return "OperationDeserializer" 508} 509 510func (m *awsAwsjson11_deserializeOpDeleteLanguageModel) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 511 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 512) { 513 out, metadata, err = next.HandleDeserialize(ctx, in) 514 if err != nil { 515 return out, metadata, err 516 } 517 518 response, ok := out.RawResponse.(*smithyhttp.Response) 519 if !ok { 520 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 521 } 522 523 if response.StatusCode < 200 || response.StatusCode >= 300 { 524 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLanguageModel(response, &metadata) 525 } 526 output := &DeleteLanguageModelOutput{} 527 out.Result = output 528 529 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 530 return out, metadata, &smithy.DeserializationError{ 531 Err: fmt.Errorf("failed to discard response body, %w", err), 532 } 533 } 534 535 return out, metadata, err 536} 537 538func awsAwsjson11_deserializeOpErrorDeleteLanguageModel(response *smithyhttp.Response, metadata *middleware.Metadata) error { 539 var errorBuffer bytes.Buffer 540 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 541 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 542 } 543 errorBody := bytes.NewReader(errorBuffer.Bytes()) 544 545 errorCode := "UnknownError" 546 errorMessage := errorCode 547 548 code := response.Header.Get("X-Amzn-ErrorType") 549 if len(code) != 0 { 550 errorCode = restjson.SanitizeErrorCode(code) 551 } 552 553 var buff [1024]byte 554 ringBuffer := smithyio.NewRingBuffer(buff[:]) 555 556 body := io.TeeReader(errorBody, ringBuffer) 557 decoder := json.NewDecoder(body) 558 decoder.UseNumber() 559 code, message, err := restjson.GetErrorInfo(decoder) 560 if err != nil { 561 var snapshot bytes.Buffer 562 io.Copy(&snapshot, ringBuffer) 563 err = &smithy.DeserializationError{ 564 Err: fmt.Errorf("failed to decode response body, %w", err), 565 Snapshot: snapshot.Bytes(), 566 } 567 return err 568 } 569 570 errorBody.Seek(0, io.SeekStart) 571 if len(code) != 0 { 572 errorCode = restjson.SanitizeErrorCode(code) 573 } 574 if len(message) != 0 { 575 errorMessage = message 576 } 577 578 switch { 579 case strings.EqualFold("BadRequestException", errorCode): 580 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 581 582 case strings.EqualFold("InternalFailureException", errorCode): 583 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 584 585 case strings.EqualFold("LimitExceededException", errorCode): 586 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 587 588 default: 589 genericError := &smithy.GenericAPIError{ 590 Code: errorCode, 591 Message: errorMessage, 592 } 593 return genericError 594 595 } 596} 597 598type awsAwsjson11_deserializeOpDeleteMedicalTranscriptionJob struct { 599} 600 601func (*awsAwsjson11_deserializeOpDeleteMedicalTranscriptionJob) ID() string { 602 return "OperationDeserializer" 603} 604 605func (m *awsAwsjson11_deserializeOpDeleteMedicalTranscriptionJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 606 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 607) { 608 out, metadata, err = next.HandleDeserialize(ctx, in) 609 if err != nil { 610 return out, metadata, err 611 } 612 613 response, ok := out.RawResponse.(*smithyhttp.Response) 614 if !ok { 615 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 616 } 617 618 if response.StatusCode < 200 || response.StatusCode >= 300 { 619 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteMedicalTranscriptionJob(response, &metadata) 620 } 621 output := &DeleteMedicalTranscriptionJobOutput{} 622 out.Result = output 623 624 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 625 return out, metadata, &smithy.DeserializationError{ 626 Err: fmt.Errorf("failed to discard response body, %w", err), 627 } 628 } 629 630 return out, metadata, err 631} 632 633func awsAwsjson11_deserializeOpErrorDeleteMedicalTranscriptionJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 634 var errorBuffer bytes.Buffer 635 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 636 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 637 } 638 errorBody := bytes.NewReader(errorBuffer.Bytes()) 639 640 errorCode := "UnknownError" 641 errorMessage := errorCode 642 643 code := response.Header.Get("X-Amzn-ErrorType") 644 if len(code) != 0 { 645 errorCode = restjson.SanitizeErrorCode(code) 646 } 647 648 var buff [1024]byte 649 ringBuffer := smithyio.NewRingBuffer(buff[:]) 650 651 body := io.TeeReader(errorBody, ringBuffer) 652 decoder := json.NewDecoder(body) 653 decoder.UseNumber() 654 code, message, err := restjson.GetErrorInfo(decoder) 655 if err != nil { 656 var snapshot bytes.Buffer 657 io.Copy(&snapshot, ringBuffer) 658 err = &smithy.DeserializationError{ 659 Err: fmt.Errorf("failed to decode response body, %w", err), 660 Snapshot: snapshot.Bytes(), 661 } 662 return err 663 } 664 665 errorBody.Seek(0, io.SeekStart) 666 if len(code) != 0 { 667 errorCode = restjson.SanitizeErrorCode(code) 668 } 669 if len(message) != 0 { 670 errorMessage = message 671 } 672 673 switch { 674 case strings.EqualFold("BadRequestException", errorCode): 675 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 676 677 case strings.EqualFold("InternalFailureException", errorCode): 678 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 679 680 case strings.EqualFold("LimitExceededException", errorCode): 681 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 682 683 default: 684 genericError := &smithy.GenericAPIError{ 685 Code: errorCode, 686 Message: errorMessage, 687 } 688 return genericError 689 690 } 691} 692 693type awsAwsjson11_deserializeOpDeleteMedicalVocabulary struct { 694} 695 696func (*awsAwsjson11_deserializeOpDeleteMedicalVocabulary) ID() string { 697 return "OperationDeserializer" 698} 699 700func (m *awsAwsjson11_deserializeOpDeleteMedicalVocabulary) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 701 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 702) { 703 out, metadata, err = next.HandleDeserialize(ctx, in) 704 if err != nil { 705 return out, metadata, err 706 } 707 708 response, ok := out.RawResponse.(*smithyhttp.Response) 709 if !ok { 710 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 711 } 712 713 if response.StatusCode < 200 || response.StatusCode >= 300 { 714 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteMedicalVocabulary(response, &metadata) 715 } 716 output := &DeleteMedicalVocabularyOutput{} 717 out.Result = output 718 719 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 720 return out, metadata, &smithy.DeserializationError{ 721 Err: fmt.Errorf("failed to discard response body, %w", err), 722 } 723 } 724 725 return out, metadata, err 726} 727 728func awsAwsjson11_deserializeOpErrorDeleteMedicalVocabulary(response *smithyhttp.Response, metadata *middleware.Metadata) error { 729 var errorBuffer bytes.Buffer 730 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 731 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 732 } 733 errorBody := bytes.NewReader(errorBuffer.Bytes()) 734 735 errorCode := "UnknownError" 736 errorMessage := errorCode 737 738 code := response.Header.Get("X-Amzn-ErrorType") 739 if len(code) != 0 { 740 errorCode = restjson.SanitizeErrorCode(code) 741 } 742 743 var buff [1024]byte 744 ringBuffer := smithyio.NewRingBuffer(buff[:]) 745 746 body := io.TeeReader(errorBody, ringBuffer) 747 decoder := json.NewDecoder(body) 748 decoder.UseNumber() 749 code, message, err := restjson.GetErrorInfo(decoder) 750 if err != nil { 751 var snapshot bytes.Buffer 752 io.Copy(&snapshot, ringBuffer) 753 err = &smithy.DeserializationError{ 754 Err: fmt.Errorf("failed to decode response body, %w", err), 755 Snapshot: snapshot.Bytes(), 756 } 757 return err 758 } 759 760 errorBody.Seek(0, io.SeekStart) 761 if len(code) != 0 { 762 errorCode = restjson.SanitizeErrorCode(code) 763 } 764 if len(message) != 0 { 765 errorMessage = message 766 } 767 768 switch { 769 case strings.EqualFold("BadRequestException", errorCode): 770 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 771 772 case strings.EqualFold("InternalFailureException", errorCode): 773 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 774 775 case strings.EqualFold("LimitExceededException", errorCode): 776 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 777 778 case strings.EqualFold("NotFoundException", errorCode): 779 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody) 780 781 default: 782 genericError := &smithy.GenericAPIError{ 783 Code: errorCode, 784 Message: errorMessage, 785 } 786 return genericError 787 788 } 789} 790 791type awsAwsjson11_deserializeOpDeleteTranscriptionJob struct { 792} 793 794func (*awsAwsjson11_deserializeOpDeleteTranscriptionJob) ID() string { 795 return "OperationDeserializer" 796} 797 798func (m *awsAwsjson11_deserializeOpDeleteTranscriptionJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 799 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 800) { 801 out, metadata, err = next.HandleDeserialize(ctx, in) 802 if err != nil { 803 return out, metadata, err 804 } 805 806 response, ok := out.RawResponse.(*smithyhttp.Response) 807 if !ok { 808 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 809 } 810 811 if response.StatusCode < 200 || response.StatusCode >= 300 { 812 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteTranscriptionJob(response, &metadata) 813 } 814 output := &DeleteTranscriptionJobOutput{} 815 out.Result = output 816 817 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 818 return out, metadata, &smithy.DeserializationError{ 819 Err: fmt.Errorf("failed to discard response body, %w", err), 820 } 821 } 822 823 return out, metadata, err 824} 825 826func awsAwsjson11_deserializeOpErrorDeleteTranscriptionJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 827 var errorBuffer bytes.Buffer 828 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 829 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 830 } 831 errorBody := bytes.NewReader(errorBuffer.Bytes()) 832 833 errorCode := "UnknownError" 834 errorMessage := errorCode 835 836 code := response.Header.Get("X-Amzn-ErrorType") 837 if len(code) != 0 { 838 errorCode = restjson.SanitizeErrorCode(code) 839 } 840 841 var buff [1024]byte 842 ringBuffer := smithyio.NewRingBuffer(buff[:]) 843 844 body := io.TeeReader(errorBody, ringBuffer) 845 decoder := json.NewDecoder(body) 846 decoder.UseNumber() 847 code, message, err := restjson.GetErrorInfo(decoder) 848 if err != nil { 849 var snapshot bytes.Buffer 850 io.Copy(&snapshot, ringBuffer) 851 err = &smithy.DeserializationError{ 852 Err: fmt.Errorf("failed to decode response body, %w", err), 853 Snapshot: snapshot.Bytes(), 854 } 855 return err 856 } 857 858 errorBody.Seek(0, io.SeekStart) 859 if len(code) != 0 { 860 errorCode = restjson.SanitizeErrorCode(code) 861 } 862 if len(message) != 0 { 863 errorMessage = message 864 } 865 866 switch { 867 case strings.EqualFold("BadRequestException", errorCode): 868 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 869 870 case strings.EqualFold("InternalFailureException", errorCode): 871 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 872 873 case strings.EqualFold("LimitExceededException", errorCode): 874 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 875 876 default: 877 genericError := &smithy.GenericAPIError{ 878 Code: errorCode, 879 Message: errorMessage, 880 } 881 return genericError 882 883 } 884} 885 886type awsAwsjson11_deserializeOpDeleteVocabulary struct { 887} 888 889func (*awsAwsjson11_deserializeOpDeleteVocabulary) ID() string { 890 return "OperationDeserializer" 891} 892 893func (m *awsAwsjson11_deserializeOpDeleteVocabulary) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 894 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 895) { 896 out, metadata, err = next.HandleDeserialize(ctx, in) 897 if err != nil { 898 return out, metadata, err 899 } 900 901 response, ok := out.RawResponse.(*smithyhttp.Response) 902 if !ok { 903 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 904 } 905 906 if response.StatusCode < 200 || response.StatusCode >= 300 { 907 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteVocabulary(response, &metadata) 908 } 909 output := &DeleteVocabularyOutput{} 910 out.Result = output 911 912 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 913 return out, metadata, &smithy.DeserializationError{ 914 Err: fmt.Errorf("failed to discard response body, %w", err), 915 } 916 } 917 918 return out, metadata, err 919} 920 921func awsAwsjson11_deserializeOpErrorDeleteVocabulary(response *smithyhttp.Response, metadata *middleware.Metadata) error { 922 var errorBuffer bytes.Buffer 923 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 924 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 925 } 926 errorBody := bytes.NewReader(errorBuffer.Bytes()) 927 928 errorCode := "UnknownError" 929 errorMessage := errorCode 930 931 code := response.Header.Get("X-Amzn-ErrorType") 932 if len(code) != 0 { 933 errorCode = restjson.SanitizeErrorCode(code) 934 } 935 936 var buff [1024]byte 937 ringBuffer := smithyio.NewRingBuffer(buff[:]) 938 939 body := io.TeeReader(errorBody, ringBuffer) 940 decoder := json.NewDecoder(body) 941 decoder.UseNumber() 942 code, message, err := restjson.GetErrorInfo(decoder) 943 if err != nil { 944 var snapshot bytes.Buffer 945 io.Copy(&snapshot, ringBuffer) 946 err = &smithy.DeserializationError{ 947 Err: fmt.Errorf("failed to decode response body, %w", err), 948 Snapshot: snapshot.Bytes(), 949 } 950 return err 951 } 952 953 errorBody.Seek(0, io.SeekStart) 954 if len(code) != 0 { 955 errorCode = restjson.SanitizeErrorCode(code) 956 } 957 if len(message) != 0 { 958 errorMessage = message 959 } 960 961 switch { 962 case strings.EqualFold("BadRequestException", errorCode): 963 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 964 965 case strings.EqualFold("InternalFailureException", errorCode): 966 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 967 968 case strings.EqualFold("LimitExceededException", errorCode): 969 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 970 971 case strings.EqualFold("NotFoundException", errorCode): 972 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody) 973 974 default: 975 genericError := &smithy.GenericAPIError{ 976 Code: errorCode, 977 Message: errorMessage, 978 } 979 return genericError 980 981 } 982} 983 984type awsAwsjson11_deserializeOpDeleteVocabularyFilter struct { 985} 986 987func (*awsAwsjson11_deserializeOpDeleteVocabularyFilter) ID() string { 988 return "OperationDeserializer" 989} 990 991func (m *awsAwsjson11_deserializeOpDeleteVocabularyFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 992 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 993) { 994 out, metadata, err = next.HandleDeserialize(ctx, in) 995 if err != nil { 996 return out, metadata, err 997 } 998 999 response, ok := out.RawResponse.(*smithyhttp.Response) 1000 if !ok { 1001 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1002 } 1003 1004 if response.StatusCode < 200 || response.StatusCode >= 300 { 1005 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteVocabularyFilter(response, &metadata) 1006 } 1007 output := &DeleteVocabularyFilterOutput{} 1008 out.Result = output 1009 1010 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1011 return out, metadata, &smithy.DeserializationError{ 1012 Err: fmt.Errorf("failed to discard response body, %w", err), 1013 } 1014 } 1015 1016 return out, metadata, err 1017} 1018 1019func awsAwsjson11_deserializeOpErrorDeleteVocabularyFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1020 var errorBuffer bytes.Buffer 1021 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1022 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1023 } 1024 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1025 1026 errorCode := "UnknownError" 1027 errorMessage := errorCode 1028 1029 code := response.Header.Get("X-Amzn-ErrorType") 1030 if len(code) != 0 { 1031 errorCode = restjson.SanitizeErrorCode(code) 1032 } 1033 1034 var buff [1024]byte 1035 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1036 1037 body := io.TeeReader(errorBody, ringBuffer) 1038 decoder := json.NewDecoder(body) 1039 decoder.UseNumber() 1040 code, message, err := restjson.GetErrorInfo(decoder) 1041 if err != nil { 1042 var snapshot bytes.Buffer 1043 io.Copy(&snapshot, ringBuffer) 1044 err = &smithy.DeserializationError{ 1045 Err: fmt.Errorf("failed to decode response body, %w", err), 1046 Snapshot: snapshot.Bytes(), 1047 } 1048 return err 1049 } 1050 1051 errorBody.Seek(0, io.SeekStart) 1052 if len(code) != 0 { 1053 errorCode = restjson.SanitizeErrorCode(code) 1054 } 1055 if len(message) != 0 { 1056 errorMessage = message 1057 } 1058 1059 switch { 1060 case strings.EqualFold("BadRequestException", errorCode): 1061 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 1062 1063 case strings.EqualFold("InternalFailureException", errorCode): 1064 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 1065 1066 case strings.EqualFold("LimitExceededException", errorCode): 1067 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1068 1069 case strings.EqualFold("NotFoundException", errorCode): 1070 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody) 1071 1072 default: 1073 genericError := &smithy.GenericAPIError{ 1074 Code: errorCode, 1075 Message: errorMessage, 1076 } 1077 return genericError 1078 1079 } 1080} 1081 1082type awsAwsjson11_deserializeOpDescribeLanguageModel struct { 1083} 1084 1085func (*awsAwsjson11_deserializeOpDescribeLanguageModel) ID() string { 1086 return "OperationDeserializer" 1087} 1088 1089func (m *awsAwsjson11_deserializeOpDescribeLanguageModel) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1090 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1091) { 1092 out, metadata, err = next.HandleDeserialize(ctx, in) 1093 if err != nil { 1094 return out, metadata, err 1095 } 1096 1097 response, ok := out.RawResponse.(*smithyhttp.Response) 1098 if !ok { 1099 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1100 } 1101 1102 if response.StatusCode < 200 || response.StatusCode >= 300 { 1103 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeLanguageModel(response, &metadata) 1104 } 1105 output := &DescribeLanguageModelOutput{} 1106 out.Result = output 1107 1108 var buff [1024]byte 1109 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1110 1111 body := io.TeeReader(response.Body, ringBuffer) 1112 decoder := json.NewDecoder(body) 1113 decoder.UseNumber() 1114 var shape interface{} 1115 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1116 var snapshot bytes.Buffer 1117 io.Copy(&snapshot, ringBuffer) 1118 err = &smithy.DeserializationError{ 1119 Err: fmt.Errorf("failed to decode response body, %w", err), 1120 Snapshot: snapshot.Bytes(), 1121 } 1122 return out, metadata, err 1123 } 1124 1125 err = awsAwsjson11_deserializeOpDocumentDescribeLanguageModelOutput(&output, shape) 1126 if err != nil { 1127 var snapshot bytes.Buffer 1128 io.Copy(&snapshot, ringBuffer) 1129 err = &smithy.DeserializationError{ 1130 Err: fmt.Errorf("failed to decode response body, %w", err), 1131 Snapshot: snapshot.Bytes(), 1132 } 1133 return out, metadata, err 1134 } 1135 1136 return out, metadata, err 1137} 1138 1139func awsAwsjson11_deserializeOpErrorDescribeLanguageModel(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1140 var errorBuffer bytes.Buffer 1141 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1142 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1143 } 1144 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1145 1146 errorCode := "UnknownError" 1147 errorMessage := errorCode 1148 1149 code := response.Header.Get("X-Amzn-ErrorType") 1150 if len(code) != 0 { 1151 errorCode = restjson.SanitizeErrorCode(code) 1152 } 1153 1154 var buff [1024]byte 1155 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1156 1157 body := io.TeeReader(errorBody, ringBuffer) 1158 decoder := json.NewDecoder(body) 1159 decoder.UseNumber() 1160 code, message, err := restjson.GetErrorInfo(decoder) 1161 if err != nil { 1162 var snapshot bytes.Buffer 1163 io.Copy(&snapshot, ringBuffer) 1164 err = &smithy.DeserializationError{ 1165 Err: fmt.Errorf("failed to decode response body, %w", err), 1166 Snapshot: snapshot.Bytes(), 1167 } 1168 return err 1169 } 1170 1171 errorBody.Seek(0, io.SeekStart) 1172 if len(code) != 0 { 1173 errorCode = restjson.SanitizeErrorCode(code) 1174 } 1175 if len(message) != 0 { 1176 errorMessage = message 1177 } 1178 1179 switch { 1180 case strings.EqualFold("BadRequestException", errorCode): 1181 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 1182 1183 case strings.EqualFold("InternalFailureException", errorCode): 1184 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 1185 1186 case strings.EqualFold("LimitExceededException", errorCode): 1187 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1188 1189 case strings.EqualFold("NotFoundException", errorCode): 1190 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody) 1191 1192 default: 1193 genericError := &smithy.GenericAPIError{ 1194 Code: errorCode, 1195 Message: errorMessage, 1196 } 1197 return genericError 1198 1199 } 1200} 1201 1202type awsAwsjson11_deserializeOpGetMedicalTranscriptionJob struct { 1203} 1204 1205func (*awsAwsjson11_deserializeOpGetMedicalTranscriptionJob) ID() string { 1206 return "OperationDeserializer" 1207} 1208 1209func (m *awsAwsjson11_deserializeOpGetMedicalTranscriptionJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1210 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1211) { 1212 out, metadata, err = next.HandleDeserialize(ctx, in) 1213 if err != nil { 1214 return out, metadata, err 1215 } 1216 1217 response, ok := out.RawResponse.(*smithyhttp.Response) 1218 if !ok { 1219 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1220 } 1221 1222 if response.StatusCode < 200 || response.StatusCode >= 300 { 1223 return out, metadata, awsAwsjson11_deserializeOpErrorGetMedicalTranscriptionJob(response, &metadata) 1224 } 1225 output := &GetMedicalTranscriptionJobOutput{} 1226 out.Result = output 1227 1228 var buff [1024]byte 1229 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1230 1231 body := io.TeeReader(response.Body, ringBuffer) 1232 decoder := json.NewDecoder(body) 1233 decoder.UseNumber() 1234 var shape interface{} 1235 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1236 var snapshot bytes.Buffer 1237 io.Copy(&snapshot, ringBuffer) 1238 err = &smithy.DeserializationError{ 1239 Err: fmt.Errorf("failed to decode response body, %w", err), 1240 Snapshot: snapshot.Bytes(), 1241 } 1242 return out, metadata, err 1243 } 1244 1245 err = awsAwsjson11_deserializeOpDocumentGetMedicalTranscriptionJobOutput(&output, shape) 1246 if err != nil { 1247 var snapshot bytes.Buffer 1248 io.Copy(&snapshot, ringBuffer) 1249 err = &smithy.DeserializationError{ 1250 Err: fmt.Errorf("failed to decode response body, %w", err), 1251 Snapshot: snapshot.Bytes(), 1252 } 1253 return out, metadata, err 1254 } 1255 1256 return out, metadata, err 1257} 1258 1259func awsAwsjson11_deserializeOpErrorGetMedicalTranscriptionJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1260 var errorBuffer bytes.Buffer 1261 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1262 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1263 } 1264 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1265 1266 errorCode := "UnknownError" 1267 errorMessage := errorCode 1268 1269 code := response.Header.Get("X-Amzn-ErrorType") 1270 if len(code) != 0 { 1271 errorCode = restjson.SanitizeErrorCode(code) 1272 } 1273 1274 var buff [1024]byte 1275 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1276 1277 body := io.TeeReader(errorBody, ringBuffer) 1278 decoder := json.NewDecoder(body) 1279 decoder.UseNumber() 1280 code, message, err := restjson.GetErrorInfo(decoder) 1281 if err != nil { 1282 var snapshot bytes.Buffer 1283 io.Copy(&snapshot, ringBuffer) 1284 err = &smithy.DeserializationError{ 1285 Err: fmt.Errorf("failed to decode response body, %w", err), 1286 Snapshot: snapshot.Bytes(), 1287 } 1288 return err 1289 } 1290 1291 errorBody.Seek(0, io.SeekStart) 1292 if len(code) != 0 { 1293 errorCode = restjson.SanitizeErrorCode(code) 1294 } 1295 if len(message) != 0 { 1296 errorMessage = message 1297 } 1298 1299 switch { 1300 case strings.EqualFold("BadRequestException", errorCode): 1301 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 1302 1303 case strings.EqualFold("InternalFailureException", errorCode): 1304 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 1305 1306 case strings.EqualFold("LimitExceededException", errorCode): 1307 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1308 1309 case strings.EqualFold("NotFoundException", errorCode): 1310 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody) 1311 1312 default: 1313 genericError := &smithy.GenericAPIError{ 1314 Code: errorCode, 1315 Message: errorMessage, 1316 } 1317 return genericError 1318 1319 } 1320} 1321 1322type awsAwsjson11_deserializeOpGetMedicalVocabulary struct { 1323} 1324 1325func (*awsAwsjson11_deserializeOpGetMedicalVocabulary) ID() string { 1326 return "OperationDeserializer" 1327} 1328 1329func (m *awsAwsjson11_deserializeOpGetMedicalVocabulary) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1330 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1331) { 1332 out, metadata, err = next.HandleDeserialize(ctx, in) 1333 if err != nil { 1334 return out, metadata, err 1335 } 1336 1337 response, ok := out.RawResponse.(*smithyhttp.Response) 1338 if !ok { 1339 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1340 } 1341 1342 if response.StatusCode < 200 || response.StatusCode >= 300 { 1343 return out, metadata, awsAwsjson11_deserializeOpErrorGetMedicalVocabulary(response, &metadata) 1344 } 1345 output := &GetMedicalVocabularyOutput{} 1346 out.Result = output 1347 1348 var buff [1024]byte 1349 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1350 1351 body := io.TeeReader(response.Body, ringBuffer) 1352 decoder := json.NewDecoder(body) 1353 decoder.UseNumber() 1354 var shape interface{} 1355 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1356 var snapshot bytes.Buffer 1357 io.Copy(&snapshot, ringBuffer) 1358 err = &smithy.DeserializationError{ 1359 Err: fmt.Errorf("failed to decode response body, %w", err), 1360 Snapshot: snapshot.Bytes(), 1361 } 1362 return out, metadata, err 1363 } 1364 1365 err = awsAwsjson11_deserializeOpDocumentGetMedicalVocabularyOutput(&output, shape) 1366 if err != nil { 1367 var snapshot bytes.Buffer 1368 io.Copy(&snapshot, ringBuffer) 1369 err = &smithy.DeserializationError{ 1370 Err: fmt.Errorf("failed to decode response body, %w", err), 1371 Snapshot: snapshot.Bytes(), 1372 } 1373 return out, metadata, err 1374 } 1375 1376 return out, metadata, err 1377} 1378 1379func awsAwsjson11_deserializeOpErrorGetMedicalVocabulary(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1380 var errorBuffer bytes.Buffer 1381 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1382 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1383 } 1384 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1385 1386 errorCode := "UnknownError" 1387 errorMessage := errorCode 1388 1389 code := response.Header.Get("X-Amzn-ErrorType") 1390 if len(code) != 0 { 1391 errorCode = restjson.SanitizeErrorCode(code) 1392 } 1393 1394 var buff [1024]byte 1395 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1396 1397 body := io.TeeReader(errorBody, ringBuffer) 1398 decoder := json.NewDecoder(body) 1399 decoder.UseNumber() 1400 code, message, err := restjson.GetErrorInfo(decoder) 1401 if err != nil { 1402 var snapshot bytes.Buffer 1403 io.Copy(&snapshot, ringBuffer) 1404 err = &smithy.DeserializationError{ 1405 Err: fmt.Errorf("failed to decode response body, %w", err), 1406 Snapshot: snapshot.Bytes(), 1407 } 1408 return err 1409 } 1410 1411 errorBody.Seek(0, io.SeekStart) 1412 if len(code) != 0 { 1413 errorCode = restjson.SanitizeErrorCode(code) 1414 } 1415 if len(message) != 0 { 1416 errorMessage = message 1417 } 1418 1419 switch { 1420 case strings.EqualFold("BadRequestException", errorCode): 1421 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 1422 1423 case strings.EqualFold("InternalFailureException", errorCode): 1424 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 1425 1426 case strings.EqualFold("LimitExceededException", errorCode): 1427 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1428 1429 case strings.EqualFold("NotFoundException", errorCode): 1430 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody) 1431 1432 default: 1433 genericError := &smithy.GenericAPIError{ 1434 Code: errorCode, 1435 Message: errorMessage, 1436 } 1437 return genericError 1438 1439 } 1440} 1441 1442type awsAwsjson11_deserializeOpGetTranscriptionJob struct { 1443} 1444 1445func (*awsAwsjson11_deserializeOpGetTranscriptionJob) ID() string { 1446 return "OperationDeserializer" 1447} 1448 1449func (m *awsAwsjson11_deserializeOpGetTranscriptionJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1450 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1451) { 1452 out, metadata, err = next.HandleDeserialize(ctx, in) 1453 if err != nil { 1454 return out, metadata, err 1455 } 1456 1457 response, ok := out.RawResponse.(*smithyhttp.Response) 1458 if !ok { 1459 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1460 } 1461 1462 if response.StatusCode < 200 || response.StatusCode >= 300 { 1463 return out, metadata, awsAwsjson11_deserializeOpErrorGetTranscriptionJob(response, &metadata) 1464 } 1465 output := &GetTranscriptionJobOutput{} 1466 out.Result = output 1467 1468 var buff [1024]byte 1469 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1470 1471 body := io.TeeReader(response.Body, ringBuffer) 1472 decoder := json.NewDecoder(body) 1473 decoder.UseNumber() 1474 var shape interface{} 1475 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1476 var snapshot bytes.Buffer 1477 io.Copy(&snapshot, ringBuffer) 1478 err = &smithy.DeserializationError{ 1479 Err: fmt.Errorf("failed to decode response body, %w", err), 1480 Snapshot: snapshot.Bytes(), 1481 } 1482 return out, metadata, err 1483 } 1484 1485 err = awsAwsjson11_deserializeOpDocumentGetTranscriptionJobOutput(&output, shape) 1486 if err != nil { 1487 var snapshot bytes.Buffer 1488 io.Copy(&snapshot, ringBuffer) 1489 err = &smithy.DeserializationError{ 1490 Err: fmt.Errorf("failed to decode response body, %w", err), 1491 Snapshot: snapshot.Bytes(), 1492 } 1493 return out, metadata, err 1494 } 1495 1496 return out, metadata, err 1497} 1498 1499func awsAwsjson11_deserializeOpErrorGetTranscriptionJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1500 var errorBuffer bytes.Buffer 1501 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1502 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1503 } 1504 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1505 1506 errorCode := "UnknownError" 1507 errorMessage := errorCode 1508 1509 code := response.Header.Get("X-Amzn-ErrorType") 1510 if len(code) != 0 { 1511 errorCode = restjson.SanitizeErrorCode(code) 1512 } 1513 1514 var buff [1024]byte 1515 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1516 1517 body := io.TeeReader(errorBody, ringBuffer) 1518 decoder := json.NewDecoder(body) 1519 decoder.UseNumber() 1520 code, message, err := restjson.GetErrorInfo(decoder) 1521 if err != nil { 1522 var snapshot bytes.Buffer 1523 io.Copy(&snapshot, ringBuffer) 1524 err = &smithy.DeserializationError{ 1525 Err: fmt.Errorf("failed to decode response body, %w", err), 1526 Snapshot: snapshot.Bytes(), 1527 } 1528 return err 1529 } 1530 1531 errorBody.Seek(0, io.SeekStart) 1532 if len(code) != 0 { 1533 errorCode = restjson.SanitizeErrorCode(code) 1534 } 1535 if len(message) != 0 { 1536 errorMessage = message 1537 } 1538 1539 switch { 1540 case strings.EqualFold("BadRequestException", errorCode): 1541 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 1542 1543 case strings.EqualFold("InternalFailureException", errorCode): 1544 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 1545 1546 case strings.EqualFold("LimitExceededException", errorCode): 1547 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1548 1549 case strings.EqualFold("NotFoundException", errorCode): 1550 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody) 1551 1552 default: 1553 genericError := &smithy.GenericAPIError{ 1554 Code: errorCode, 1555 Message: errorMessage, 1556 } 1557 return genericError 1558 1559 } 1560} 1561 1562type awsAwsjson11_deserializeOpGetVocabulary struct { 1563} 1564 1565func (*awsAwsjson11_deserializeOpGetVocabulary) ID() string { 1566 return "OperationDeserializer" 1567} 1568 1569func (m *awsAwsjson11_deserializeOpGetVocabulary) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1570 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1571) { 1572 out, metadata, err = next.HandleDeserialize(ctx, in) 1573 if err != nil { 1574 return out, metadata, err 1575 } 1576 1577 response, ok := out.RawResponse.(*smithyhttp.Response) 1578 if !ok { 1579 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1580 } 1581 1582 if response.StatusCode < 200 || response.StatusCode >= 300 { 1583 return out, metadata, awsAwsjson11_deserializeOpErrorGetVocabulary(response, &metadata) 1584 } 1585 output := &GetVocabularyOutput{} 1586 out.Result = output 1587 1588 var buff [1024]byte 1589 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1590 1591 body := io.TeeReader(response.Body, ringBuffer) 1592 decoder := json.NewDecoder(body) 1593 decoder.UseNumber() 1594 var shape interface{} 1595 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1596 var snapshot bytes.Buffer 1597 io.Copy(&snapshot, ringBuffer) 1598 err = &smithy.DeserializationError{ 1599 Err: fmt.Errorf("failed to decode response body, %w", err), 1600 Snapshot: snapshot.Bytes(), 1601 } 1602 return out, metadata, err 1603 } 1604 1605 err = awsAwsjson11_deserializeOpDocumentGetVocabularyOutput(&output, shape) 1606 if err != nil { 1607 var snapshot bytes.Buffer 1608 io.Copy(&snapshot, ringBuffer) 1609 err = &smithy.DeserializationError{ 1610 Err: fmt.Errorf("failed to decode response body, %w", err), 1611 Snapshot: snapshot.Bytes(), 1612 } 1613 return out, metadata, err 1614 } 1615 1616 return out, metadata, err 1617} 1618 1619func awsAwsjson11_deserializeOpErrorGetVocabulary(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1620 var errorBuffer bytes.Buffer 1621 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1622 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1623 } 1624 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1625 1626 errorCode := "UnknownError" 1627 errorMessage := errorCode 1628 1629 code := response.Header.Get("X-Amzn-ErrorType") 1630 if len(code) != 0 { 1631 errorCode = restjson.SanitizeErrorCode(code) 1632 } 1633 1634 var buff [1024]byte 1635 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1636 1637 body := io.TeeReader(errorBody, ringBuffer) 1638 decoder := json.NewDecoder(body) 1639 decoder.UseNumber() 1640 code, message, err := restjson.GetErrorInfo(decoder) 1641 if err != nil { 1642 var snapshot bytes.Buffer 1643 io.Copy(&snapshot, ringBuffer) 1644 err = &smithy.DeserializationError{ 1645 Err: fmt.Errorf("failed to decode response body, %w", err), 1646 Snapshot: snapshot.Bytes(), 1647 } 1648 return err 1649 } 1650 1651 errorBody.Seek(0, io.SeekStart) 1652 if len(code) != 0 { 1653 errorCode = restjson.SanitizeErrorCode(code) 1654 } 1655 if len(message) != 0 { 1656 errorMessage = message 1657 } 1658 1659 switch { 1660 case strings.EqualFold("BadRequestException", errorCode): 1661 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 1662 1663 case strings.EqualFold("InternalFailureException", errorCode): 1664 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 1665 1666 case strings.EqualFold("LimitExceededException", errorCode): 1667 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1668 1669 case strings.EqualFold("NotFoundException", errorCode): 1670 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody) 1671 1672 default: 1673 genericError := &smithy.GenericAPIError{ 1674 Code: errorCode, 1675 Message: errorMessage, 1676 } 1677 return genericError 1678 1679 } 1680} 1681 1682type awsAwsjson11_deserializeOpGetVocabularyFilter struct { 1683} 1684 1685func (*awsAwsjson11_deserializeOpGetVocabularyFilter) ID() string { 1686 return "OperationDeserializer" 1687} 1688 1689func (m *awsAwsjson11_deserializeOpGetVocabularyFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1690 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1691) { 1692 out, metadata, err = next.HandleDeserialize(ctx, in) 1693 if err != nil { 1694 return out, metadata, err 1695 } 1696 1697 response, ok := out.RawResponse.(*smithyhttp.Response) 1698 if !ok { 1699 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1700 } 1701 1702 if response.StatusCode < 200 || response.StatusCode >= 300 { 1703 return out, metadata, awsAwsjson11_deserializeOpErrorGetVocabularyFilter(response, &metadata) 1704 } 1705 output := &GetVocabularyFilterOutput{} 1706 out.Result = output 1707 1708 var buff [1024]byte 1709 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1710 1711 body := io.TeeReader(response.Body, ringBuffer) 1712 decoder := json.NewDecoder(body) 1713 decoder.UseNumber() 1714 var shape interface{} 1715 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1716 var snapshot bytes.Buffer 1717 io.Copy(&snapshot, ringBuffer) 1718 err = &smithy.DeserializationError{ 1719 Err: fmt.Errorf("failed to decode response body, %w", err), 1720 Snapshot: snapshot.Bytes(), 1721 } 1722 return out, metadata, err 1723 } 1724 1725 err = awsAwsjson11_deserializeOpDocumentGetVocabularyFilterOutput(&output, shape) 1726 if err != nil { 1727 var snapshot bytes.Buffer 1728 io.Copy(&snapshot, ringBuffer) 1729 err = &smithy.DeserializationError{ 1730 Err: fmt.Errorf("failed to decode response body, %w", err), 1731 Snapshot: snapshot.Bytes(), 1732 } 1733 return out, metadata, err 1734 } 1735 1736 return out, metadata, err 1737} 1738 1739func awsAwsjson11_deserializeOpErrorGetVocabularyFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1740 var errorBuffer bytes.Buffer 1741 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1742 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1743 } 1744 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1745 1746 errorCode := "UnknownError" 1747 errorMessage := errorCode 1748 1749 code := response.Header.Get("X-Amzn-ErrorType") 1750 if len(code) != 0 { 1751 errorCode = restjson.SanitizeErrorCode(code) 1752 } 1753 1754 var buff [1024]byte 1755 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1756 1757 body := io.TeeReader(errorBody, ringBuffer) 1758 decoder := json.NewDecoder(body) 1759 decoder.UseNumber() 1760 code, message, err := restjson.GetErrorInfo(decoder) 1761 if err != nil { 1762 var snapshot bytes.Buffer 1763 io.Copy(&snapshot, ringBuffer) 1764 err = &smithy.DeserializationError{ 1765 Err: fmt.Errorf("failed to decode response body, %w", err), 1766 Snapshot: snapshot.Bytes(), 1767 } 1768 return err 1769 } 1770 1771 errorBody.Seek(0, io.SeekStart) 1772 if len(code) != 0 { 1773 errorCode = restjson.SanitizeErrorCode(code) 1774 } 1775 if len(message) != 0 { 1776 errorMessage = message 1777 } 1778 1779 switch { 1780 case strings.EqualFold("BadRequestException", errorCode): 1781 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 1782 1783 case strings.EqualFold("InternalFailureException", errorCode): 1784 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 1785 1786 case strings.EqualFold("LimitExceededException", errorCode): 1787 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1788 1789 case strings.EqualFold("NotFoundException", errorCode): 1790 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody) 1791 1792 default: 1793 genericError := &smithy.GenericAPIError{ 1794 Code: errorCode, 1795 Message: errorMessage, 1796 } 1797 return genericError 1798 1799 } 1800} 1801 1802type awsAwsjson11_deserializeOpListLanguageModels struct { 1803} 1804 1805func (*awsAwsjson11_deserializeOpListLanguageModels) ID() string { 1806 return "OperationDeserializer" 1807} 1808 1809func (m *awsAwsjson11_deserializeOpListLanguageModels) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1810 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1811) { 1812 out, metadata, err = next.HandleDeserialize(ctx, in) 1813 if err != nil { 1814 return out, metadata, err 1815 } 1816 1817 response, ok := out.RawResponse.(*smithyhttp.Response) 1818 if !ok { 1819 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1820 } 1821 1822 if response.StatusCode < 200 || response.StatusCode >= 300 { 1823 return out, metadata, awsAwsjson11_deserializeOpErrorListLanguageModels(response, &metadata) 1824 } 1825 output := &ListLanguageModelsOutput{} 1826 out.Result = output 1827 1828 var buff [1024]byte 1829 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1830 1831 body := io.TeeReader(response.Body, ringBuffer) 1832 decoder := json.NewDecoder(body) 1833 decoder.UseNumber() 1834 var shape interface{} 1835 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1836 var snapshot bytes.Buffer 1837 io.Copy(&snapshot, ringBuffer) 1838 err = &smithy.DeserializationError{ 1839 Err: fmt.Errorf("failed to decode response body, %w", err), 1840 Snapshot: snapshot.Bytes(), 1841 } 1842 return out, metadata, err 1843 } 1844 1845 err = awsAwsjson11_deserializeOpDocumentListLanguageModelsOutput(&output, shape) 1846 if err != nil { 1847 var snapshot bytes.Buffer 1848 io.Copy(&snapshot, ringBuffer) 1849 err = &smithy.DeserializationError{ 1850 Err: fmt.Errorf("failed to decode response body, %w", err), 1851 Snapshot: snapshot.Bytes(), 1852 } 1853 return out, metadata, err 1854 } 1855 1856 return out, metadata, err 1857} 1858 1859func awsAwsjson11_deserializeOpErrorListLanguageModels(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1860 var errorBuffer bytes.Buffer 1861 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1862 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1863 } 1864 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1865 1866 errorCode := "UnknownError" 1867 errorMessage := errorCode 1868 1869 code := response.Header.Get("X-Amzn-ErrorType") 1870 if len(code) != 0 { 1871 errorCode = restjson.SanitizeErrorCode(code) 1872 } 1873 1874 var buff [1024]byte 1875 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1876 1877 body := io.TeeReader(errorBody, ringBuffer) 1878 decoder := json.NewDecoder(body) 1879 decoder.UseNumber() 1880 code, message, err := restjson.GetErrorInfo(decoder) 1881 if err != nil { 1882 var snapshot bytes.Buffer 1883 io.Copy(&snapshot, ringBuffer) 1884 err = &smithy.DeserializationError{ 1885 Err: fmt.Errorf("failed to decode response body, %w", err), 1886 Snapshot: snapshot.Bytes(), 1887 } 1888 return err 1889 } 1890 1891 errorBody.Seek(0, io.SeekStart) 1892 if len(code) != 0 { 1893 errorCode = restjson.SanitizeErrorCode(code) 1894 } 1895 if len(message) != 0 { 1896 errorMessage = message 1897 } 1898 1899 switch { 1900 case strings.EqualFold("BadRequestException", errorCode): 1901 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 1902 1903 case strings.EqualFold("InternalFailureException", errorCode): 1904 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 1905 1906 case strings.EqualFold("LimitExceededException", errorCode): 1907 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1908 1909 default: 1910 genericError := &smithy.GenericAPIError{ 1911 Code: errorCode, 1912 Message: errorMessage, 1913 } 1914 return genericError 1915 1916 } 1917} 1918 1919type awsAwsjson11_deserializeOpListMedicalTranscriptionJobs struct { 1920} 1921 1922func (*awsAwsjson11_deserializeOpListMedicalTranscriptionJobs) ID() string { 1923 return "OperationDeserializer" 1924} 1925 1926func (m *awsAwsjson11_deserializeOpListMedicalTranscriptionJobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1927 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1928) { 1929 out, metadata, err = next.HandleDeserialize(ctx, in) 1930 if err != nil { 1931 return out, metadata, err 1932 } 1933 1934 response, ok := out.RawResponse.(*smithyhttp.Response) 1935 if !ok { 1936 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1937 } 1938 1939 if response.StatusCode < 200 || response.StatusCode >= 300 { 1940 return out, metadata, awsAwsjson11_deserializeOpErrorListMedicalTranscriptionJobs(response, &metadata) 1941 } 1942 output := &ListMedicalTranscriptionJobsOutput{} 1943 out.Result = output 1944 1945 var buff [1024]byte 1946 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1947 1948 body := io.TeeReader(response.Body, ringBuffer) 1949 decoder := json.NewDecoder(body) 1950 decoder.UseNumber() 1951 var shape interface{} 1952 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1953 var snapshot bytes.Buffer 1954 io.Copy(&snapshot, ringBuffer) 1955 err = &smithy.DeserializationError{ 1956 Err: fmt.Errorf("failed to decode response body, %w", err), 1957 Snapshot: snapshot.Bytes(), 1958 } 1959 return out, metadata, err 1960 } 1961 1962 err = awsAwsjson11_deserializeOpDocumentListMedicalTranscriptionJobsOutput(&output, shape) 1963 if err != nil { 1964 var snapshot bytes.Buffer 1965 io.Copy(&snapshot, ringBuffer) 1966 err = &smithy.DeserializationError{ 1967 Err: fmt.Errorf("failed to decode response body, %w", err), 1968 Snapshot: snapshot.Bytes(), 1969 } 1970 return out, metadata, err 1971 } 1972 1973 return out, metadata, err 1974} 1975 1976func awsAwsjson11_deserializeOpErrorListMedicalTranscriptionJobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1977 var errorBuffer bytes.Buffer 1978 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1979 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1980 } 1981 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1982 1983 errorCode := "UnknownError" 1984 errorMessage := errorCode 1985 1986 code := response.Header.Get("X-Amzn-ErrorType") 1987 if len(code) != 0 { 1988 errorCode = restjson.SanitizeErrorCode(code) 1989 } 1990 1991 var buff [1024]byte 1992 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1993 1994 body := io.TeeReader(errorBody, ringBuffer) 1995 decoder := json.NewDecoder(body) 1996 decoder.UseNumber() 1997 code, message, err := restjson.GetErrorInfo(decoder) 1998 if err != nil { 1999 var snapshot bytes.Buffer 2000 io.Copy(&snapshot, ringBuffer) 2001 err = &smithy.DeserializationError{ 2002 Err: fmt.Errorf("failed to decode response body, %w", err), 2003 Snapshot: snapshot.Bytes(), 2004 } 2005 return err 2006 } 2007 2008 errorBody.Seek(0, io.SeekStart) 2009 if len(code) != 0 { 2010 errorCode = restjson.SanitizeErrorCode(code) 2011 } 2012 if len(message) != 0 { 2013 errorMessage = message 2014 } 2015 2016 switch { 2017 case strings.EqualFold("BadRequestException", errorCode): 2018 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 2019 2020 case strings.EqualFold("InternalFailureException", errorCode): 2021 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 2022 2023 case strings.EqualFold("LimitExceededException", errorCode): 2024 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 2025 2026 default: 2027 genericError := &smithy.GenericAPIError{ 2028 Code: errorCode, 2029 Message: errorMessage, 2030 } 2031 return genericError 2032 2033 } 2034} 2035 2036type awsAwsjson11_deserializeOpListMedicalVocabularies struct { 2037} 2038 2039func (*awsAwsjson11_deserializeOpListMedicalVocabularies) ID() string { 2040 return "OperationDeserializer" 2041} 2042 2043func (m *awsAwsjson11_deserializeOpListMedicalVocabularies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2044 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2045) { 2046 out, metadata, err = next.HandleDeserialize(ctx, in) 2047 if err != nil { 2048 return out, metadata, err 2049 } 2050 2051 response, ok := out.RawResponse.(*smithyhttp.Response) 2052 if !ok { 2053 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2054 } 2055 2056 if response.StatusCode < 200 || response.StatusCode >= 300 { 2057 return out, metadata, awsAwsjson11_deserializeOpErrorListMedicalVocabularies(response, &metadata) 2058 } 2059 output := &ListMedicalVocabulariesOutput{} 2060 out.Result = output 2061 2062 var buff [1024]byte 2063 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2064 2065 body := io.TeeReader(response.Body, ringBuffer) 2066 decoder := json.NewDecoder(body) 2067 decoder.UseNumber() 2068 var shape interface{} 2069 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2070 var snapshot bytes.Buffer 2071 io.Copy(&snapshot, ringBuffer) 2072 err = &smithy.DeserializationError{ 2073 Err: fmt.Errorf("failed to decode response body, %w", err), 2074 Snapshot: snapshot.Bytes(), 2075 } 2076 return out, metadata, err 2077 } 2078 2079 err = awsAwsjson11_deserializeOpDocumentListMedicalVocabulariesOutput(&output, shape) 2080 if err != nil { 2081 var snapshot bytes.Buffer 2082 io.Copy(&snapshot, ringBuffer) 2083 err = &smithy.DeserializationError{ 2084 Err: fmt.Errorf("failed to decode response body, %w", err), 2085 Snapshot: snapshot.Bytes(), 2086 } 2087 return out, metadata, err 2088 } 2089 2090 return out, metadata, err 2091} 2092 2093func awsAwsjson11_deserializeOpErrorListMedicalVocabularies(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2094 var errorBuffer bytes.Buffer 2095 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2096 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2097 } 2098 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2099 2100 errorCode := "UnknownError" 2101 errorMessage := errorCode 2102 2103 code := response.Header.Get("X-Amzn-ErrorType") 2104 if len(code) != 0 { 2105 errorCode = restjson.SanitizeErrorCode(code) 2106 } 2107 2108 var buff [1024]byte 2109 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2110 2111 body := io.TeeReader(errorBody, ringBuffer) 2112 decoder := json.NewDecoder(body) 2113 decoder.UseNumber() 2114 code, message, err := restjson.GetErrorInfo(decoder) 2115 if err != nil { 2116 var snapshot bytes.Buffer 2117 io.Copy(&snapshot, ringBuffer) 2118 err = &smithy.DeserializationError{ 2119 Err: fmt.Errorf("failed to decode response body, %w", err), 2120 Snapshot: snapshot.Bytes(), 2121 } 2122 return err 2123 } 2124 2125 errorBody.Seek(0, io.SeekStart) 2126 if len(code) != 0 { 2127 errorCode = restjson.SanitizeErrorCode(code) 2128 } 2129 if len(message) != 0 { 2130 errorMessage = message 2131 } 2132 2133 switch { 2134 case strings.EqualFold("BadRequestException", errorCode): 2135 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 2136 2137 case strings.EqualFold("InternalFailureException", errorCode): 2138 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 2139 2140 case strings.EqualFold("LimitExceededException", errorCode): 2141 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 2142 2143 default: 2144 genericError := &smithy.GenericAPIError{ 2145 Code: errorCode, 2146 Message: errorMessage, 2147 } 2148 return genericError 2149 2150 } 2151} 2152 2153type awsAwsjson11_deserializeOpListTranscriptionJobs struct { 2154} 2155 2156func (*awsAwsjson11_deserializeOpListTranscriptionJobs) ID() string { 2157 return "OperationDeserializer" 2158} 2159 2160func (m *awsAwsjson11_deserializeOpListTranscriptionJobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2161 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2162) { 2163 out, metadata, err = next.HandleDeserialize(ctx, in) 2164 if err != nil { 2165 return out, metadata, err 2166 } 2167 2168 response, ok := out.RawResponse.(*smithyhttp.Response) 2169 if !ok { 2170 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2171 } 2172 2173 if response.StatusCode < 200 || response.StatusCode >= 300 { 2174 return out, metadata, awsAwsjson11_deserializeOpErrorListTranscriptionJobs(response, &metadata) 2175 } 2176 output := &ListTranscriptionJobsOutput{} 2177 out.Result = output 2178 2179 var buff [1024]byte 2180 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2181 2182 body := io.TeeReader(response.Body, ringBuffer) 2183 decoder := json.NewDecoder(body) 2184 decoder.UseNumber() 2185 var shape interface{} 2186 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2187 var snapshot bytes.Buffer 2188 io.Copy(&snapshot, ringBuffer) 2189 err = &smithy.DeserializationError{ 2190 Err: fmt.Errorf("failed to decode response body, %w", err), 2191 Snapshot: snapshot.Bytes(), 2192 } 2193 return out, metadata, err 2194 } 2195 2196 err = awsAwsjson11_deserializeOpDocumentListTranscriptionJobsOutput(&output, shape) 2197 if err != nil { 2198 var snapshot bytes.Buffer 2199 io.Copy(&snapshot, ringBuffer) 2200 err = &smithy.DeserializationError{ 2201 Err: fmt.Errorf("failed to decode response body, %w", err), 2202 Snapshot: snapshot.Bytes(), 2203 } 2204 return out, metadata, err 2205 } 2206 2207 return out, metadata, err 2208} 2209 2210func awsAwsjson11_deserializeOpErrorListTranscriptionJobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2211 var errorBuffer bytes.Buffer 2212 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2213 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2214 } 2215 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2216 2217 errorCode := "UnknownError" 2218 errorMessage := errorCode 2219 2220 code := response.Header.Get("X-Amzn-ErrorType") 2221 if len(code) != 0 { 2222 errorCode = restjson.SanitizeErrorCode(code) 2223 } 2224 2225 var buff [1024]byte 2226 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2227 2228 body := io.TeeReader(errorBody, ringBuffer) 2229 decoder := json.NewDecoder(body) 2230 decoder.UseNumber() 2231 code, message, err := restjson.GetErrorInfo(decoder) 2232 if err != nil { 2233 var snapshot bytes.Buffer 2234 io.Copy(&snapshot, ringBuffer) 2235 err = &smithy.DeserializationError{ 2236 Err: fmt.Errorf("failed to decode response body, %w", err), 2237 Snapshot: snapshot.Bytes(), 2238 } 2239 return err 2240 } 2241 2242 errorBody.Seek(0, io.SeekStart) 2243 if len(code) != 0 { 2244 errorCode = restjson.SanitizeErrorCode(code) 2245 } 2246 if len(message) != 0 { 2247 errorMessage = message 2248 } 2249 2250 switch { 2251 case strings.EqualFold("BadRequestException", errorCode): 2252 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 2253 2254 case strings.EqualFold("InternalFailureException", errorCode): 2255 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 2256 2257 case strings.EqualFold("LimitExceededException", errorCode): 2258 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 2259 2260 default: 2261 genericError := &smithy.GenericAPIError{ 2262 Code: errorCode, 2263 Message: errorMessage, 2264 } 2265 return genericError 2266 2267 } 2268} 2269 2270type awsAwsjson11_deserializeOpListVocabularies struct { 2271} 2272 2273func (*awsAwsjson11_deserializeOpListVocabularies) ID() string { 2274 return "OperationDeserializer" 2275} 2276 2277func (m *awsAwsjson11_deserializeOpListVocabularies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2278 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2279) { 2280 out, metadata, err = next.HandleDeserialize(ctx, in) 2281 if err != nil { 2282 return out, metadata, err 2283 } 2284 2285 response, ok := out.RawResponse.(*smithyhttp.Response) 2286 if !ok { 2287 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2288 } 2289 2290 if response.StatusCode < 200 || response.StatusCode >= 300 { 2291 return out, metadata, awsAwsjson11_deserializeOpErrorListVocabularies(response, &metadata) 2292 } 2293 output := &ListVocabulariesOutput{} 2294 out.Result = output 2295 2296 var buff [1024]byte 2297 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2298 2299 body := io.TeeReader(response.Body, ringBuffer) 2300 decoder := json.NewDecoder(body) 2301 decoder.UseNumber() 2302 var shape interface{} 2303 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2304 var snapshot bytes.Buffer 2305 io.Copy(&snapshot, ringBuffer) 2306 err = &smithy.DeserializationError{ 2307 Err: fmt.Errorf("failed to decode response body, %w", err), 2308 Snapshot: snapshot.Bytes(), 2309 } 2310 return out, metadata, err 2311 } 2312 2313 err = awsAwsjson11_deserializeOpDocumentListVocabulariesOutput(&output, shape) 2314 if err != nil { 2315 var snapshot bytes.Buffer 2316 io.Copy(&snapshot, ringBuffer) 2317 err = &smithy.DeserializationError{ 2318 Err: fmt.Errorf("failed to decode response body, %w", err), 2319 Snapshot: snapshot.Bytes(), 2320 } 2321 return out, metadata, err 2322 } 2323 2324 return out, metadata, err 2325} 2326 2327func awsAwsjson11_deserializeOpErrorListVocabularies(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2328 var errorBuffer bytes.Buffer 2329 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2330 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2331 } 2332 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2333 2334 errorCode := "UnknownError" 2335 errorMessage := errorCode 2336 2337 code := response.Header.Get("X-Amzn-ErrorType") 2338 if len(code) != 0 { 2339 errorCode = restjson.SanitizeErrorCode(code) 2340 } 2341 2342 var buff [1024]byte 2343 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2344 2345 body := io.TeeReader(errorBody, ringBuffer) 2346 decoder := json.NewDecoder(body) 2347 decoder.UseNumber() 2348 code, message, err := restjson.GetErrorInfo(decoder) 2349 if err != nil { 2350 var snapshot bytes.Buffer 2351 io.Copy(&snapshot, ringBuffer) 2352 err = &smithy.DeserializationError{ 2353 Err: fmt.Errorf("failed to decode response body, %w", err), 2354 Snapshot: snapshot.Bytes(), 2355 } 2356 return err 2357 } 2358 2359 errorBody.Seek(0, io.SeekStart) 2360 if len(code) != 0 { 2361 errorCode = restjson.SanitizeErrorCode(code) 2362 } 2363 if len(message) != 0 { 2364 errorMessage = message 2365 } 2366 2367 switch { 2368 case strings.EqualFold("BadRequestException", errorCode): 2369 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 2370 2371 case strings.EqualFold("InternalFailureException", errorCode): 2372 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 2373 2374 case strings.EqualFold("LimitExceededException", errorCode): 2375 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 2376 2377 default: 2378 genericError := &smithy.GenericAPIError{ 2379 Code: errorCode, 2380 Message: errorMessage, 2381 } 2382 return genericError 2383 2384 } 2385} 2386 2387type awsAwsjson11_deserializeOpListVocabularyFilters struct { 2388} 2389 2390func (*awsAwsjson11_deserializeOpListVocabularyFilters) ID() string { 2391 return "OperationDeserializer" 2392} 2393 2394func (m *awsAwsjson11_deserializeOpListVocabularyFilters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2395 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2396) { 2397 out, metadata, err = next.HandleDeserialize(ctx, in) 2398 if err != nil { 2399 return out, metadata, err 2400 } 2401 2402 response, ok := out.RawResponse.(*smithyhttp.Response) 2403 if !ok { 2404 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2405 } 2406 2407 if response.StatusCode < 200 || response.StatusCode >= 300 { 2408 return out, metadata, awsAwsjson11_deserializeOpErrorListVocabularyFilters(response, &metadata) 2409 } 2410 output := &ListVocabularyFiltersOutput{} 2411 out.Result = output 2412 2413 var buff [1024]byte 2414 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2415 2416 body := io.TeeReader(response.Body, ringBuffer) 2417 decoder := json.NewDecoder(body) 2418 decoder.UseNumber() 2419 var shape interface{} 2420 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2421 var snapshot bytes.Buffer 2422 io.Copy(&snapshot, ringBuffer) 2423 err = &smithy.DeserializationError{ 2424 Err: fmt.Errorf("failed to decode response body, %w", err), 2425 Snapshot: snapshot.Bytes(), 2426 } 2427 return out, metadata, err 2428 } 2429 2430 err = awsAwsjson11_deserializeOpDocumentListVocabularyFiltersOutput(&output, shape) 2431 if err != nil { 2432 var snapshot bytes.Buffer 2433 io.Copy(&snapshot, ringBuffer) 2434 err = &smithy.DeserializationError{ 2435 Err: fmt.Errorf("failed to decode response body, %w", err), 2436 Snapshot: snapshot.Bytes(), 2437 } 2438 return out, metadata, err 2439 } 2440 2441 return out, metadata, err 2442} 2443 2444func awsAwsjson11_deserializeOpErrorListVocabularyFilters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2445 var errorBuffer bytes.Buffer 2446 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2447 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2448 } 2449 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2450 2451 errorCode := "UnknownError" 2452 errorMessage := errorCode 2453 2454 code := response.Header.Get("X-Amzn-ErrorType") 2455 if len(code) != 0 { 2456 errorCode = restjson.SanitizeErrorCode(code) 2457 } 2458 2459 var buff [1024]byte 2460 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2461 2462 body := io.TeeReader(errorBody, ringBuffer) 2463 decoder := json.NewDecoder(body) 2464 decoder.UseNumber() 2465 code, message, err := restjson.GetErrorInfo(decoder) 2466 if err != nil { 2467 var snapshot bytes.Buffer 2468 io.Copy(&snapshot, ringBuffer) 2469 err = &smithy.DeserializationError{ 2470 Err: fmt.Errorf("failed to decode response body, %w", err), 2471 Snapshot: snapshot.Bytes(), 2472 } 2473 return err 2474 } 2475 2476 errorBody.Seek(0, io.SeekStart) 2477 if len(code) != 0 { 2478 errorCode = restjson.SanitizeErrorCode(code) 2479 } 2480 if len(message) != 0 { 2481 errorMessage = message 2482 } 2483 2484 switch { 2485 case strings.EqualFold("BadRequestException", errorCode): 2486 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 2487 2488 case strings.EqualFold("InternalFailureException", errorCode): 2489 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 2490 2491 case strings.EqualFold("LimitExceededException", errorCode): 2492 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 2493 2494 default: 2495 genericError := &smithy.GenericAPIError{ 2496 Code: errorCode, 2497 Message: errorMessage, 2498 } 2499 return genericError 2500 2501 } 2502} 2503 2504type awsAwsjson11_deserializeOpStartMedicalTranscriptionJob struct { 2505} 2506 2507func (*awsAwsjson11_deserializeOpStartMedicalTranscriptionJob) ID() string { 2508 return "OperationDeserializer" 2509} 2510 2511func (m *awsAwsjson11_deserializeOpStartMedicalTranscriptionJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2512 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2513) { 2514 out, metadata, err = next.HandleDeserialize(ctx, in) 2515 if err != nil { 2516 return out, metadata, err 2517 } 2518 2519 response, ok := out.RawResponse.(*smithyhttp.Response) 2520 if !ok { 2521 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2522 } 2523 2524 if response.StatusCode < 200 || response.StatusCode >= 300 { 2525 return out, metadata, awsAwsjson11_deserializeOpErrorStartMedicalTranscriptionJob(response, &metadata) 2526 } 2527 output := &StartMedicalTranscriptionJobOutput{} 2528 out.Result = output 2529 2530 var buff [1024]byte 2531 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2532 2533 body := io.TeeReader(response.Body, ringBuffer) 2534 decoder := json.NewDecoder(body) 2535 decoder.UseNumber() 2536 var shape interface{} 2537 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2538 var snapshot bytes.Buffer 2539 io.Copy(&snapshot, ringBuffer) 2540 err = &smithy.DeserializationError{ 2541 Err: fmt.Errorf("failed to decode response body, %w", err), 2542 Snapshot: snapshot.Bytes(), 2543 } 2544 return out, metadata, err 2545 } 2546 2547 err = awsAwsjson11_deserializeOpDocumentStartMedicalTranscriptionJobOutput(&output, shape) 2548 if err != nil { 2549 var snapshot bytes.Buffer 2550 io.Copy(&snapshot, ringBuffer) 2551 err = &smithy.DeserializationError{ 2552 Err: fmt.Errorf("failed to decode response body, %w", err), 2553 Snapshot: snapshot.Bytes(), 2554 } 2555 return out, metadata, err 2556 } 2557 2558 return out, metadata, err 2559} 2560 2561func awsAwsjson11_deserializeOpErrorStartMedicalTranscriptionJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2562 var errorBuffer bytes.Buffer 2563 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2564 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2565 } 2566 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2567 2568 errorCode := "UnknownError" 2569 errorMessage := errorCode 2570 2571 code := response.Header.Get("X-Amzn-ErrorType") 2572 if len(code) != 0 { 2573 errorCode = restjson.SanitizeErrorCode(code) 2574 } 2575 2576 var buff [1024]byte 2577 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2578 2579 body := io.TeeReader(errorBody, ringBuffer) 2580 decoder := json.NewDecoder(body) 2581 decoder.UseNumber() 2582 code, message, err := restjson.GetErrorInfo(decoder) 2583 if err != nil { 2584 var snapshot bytes.Buffer 2585 io.Copy(&snapshot, ringBuffer) 2586 err = &smithy.DeserializationError{ 2587 Err: fmt.Errorf("failed to decode response body, %w", err), 2588 Snapshot: snapshot.Bytes(), 2589 } 2590 return err 2591 } 2592 2593 errorBody.Seek(0, io.SeekStart) 2594 if len(code) != 0 { 2595 errorCode = restjson.SanitizeErrorCode(code) 2596 } 2597 if len(message) != 0 { 2598 errorMessage = message 2599 } 2600 2601 switch { 2602 case strings.EqualFold("BadRequestException", errorCode): 2603 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 2604 2605 case strings.EqualFold("ConflictException", errorCode): 2606 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 2607 2608 case strings.EqualFold("InternalFailureException", errorCode): 2609 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 2610 2611 case strings.EqualFold("LimitExceededException", errorCode): 2612 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 2613 2614 default: 2615 genericError := &smithy.GenericAPIError{ 2616 Code: errorCode, 2617 Message: errorMessage, 2618 } 2619 return genericError 2620 2621 } 2622} 2623 2624type awsAwsjson11_deserializeOpStartTranscriptionJob struct { 2625} 2626 2627func (*awsAwsjson11_deserializeOpStartTranscriptionJob) ID() string { 2628 return "OperationDeserializer" 2629} 2630 2631func (m *awsAwsjson11_deserializeOpStartTranscriptionJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2632 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2633) { 2634 out, metadata, err = next.HandleDeserialize(ctx, in) 2635 if err != nil { 2636 return out, metadata, err 2637 } 2638 2639 response, ok := out.RawResponse.(*smithyhttp.Response) 2640 if !ok { 2641 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2642 } 2643 2644 if response.StatusCode < 200 || response.StatusCode >= 300 { 2645 return out, metadata, awsAwsjson11_deserializeOpErrorStartTranscriptionJob(response, &metadata) 2646 } 2647 output := &StartTranscriptionJobOutput{} 2648 out.Result = output 2649 2650 var buff [1024]byte 2651 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2652 2653 body := io.TeeReader(response.Body, ringBuffer) 2654 decoder := json.NewDecoder(body) 2655 decoder.UseNumber() 2656 var shape interface{} 2657 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2658 var snapshot bytes.Buffer 2659 io.Copy(&snapshot, ringBuffer) 2660 err = &smithy.DeserializationError{ 2661 Err: fmt.Errorf("failed to decode response body, %w", err), 2662 Snapshot: snapshot.Bytes(), 2663 } 2664 return out, metadata, err 2665 } 2666 2667 err = awsAwsjson11_deserializeOpDocumentStartTranscriptionJobOutput(&output, shape) 2668 if err != nil { 2669 var snapshot bytes.Buffer 2670 io.Copy(&snapshot, ringBuffer) 2671 err = &smithy.DeserializationError{ 2672 Err: fmt.Errorf("failed to decode response body, %w", err), 2673 Snapshot: snapshot.Bytes(), 2674 } 2675 return out, metadata, err 2676 } 2677 2678 return out, metadata, err 2679} 2680 2681func awsAwsjson11_deserializeOpErrorStartTranscriptionJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2682 var errorBuffer bytes.Buffer 2683 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2684 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2685 } 2686 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2687 2688 errorCode := "UnknownError" 2689 errorMessage := errorCode 2690 2691 code := response.Header.Get("X-Amzn-ErrorType") 2692 if len(code) != 0 { 2693 errorCode = restjson.SanitizeErrorCode(code) 2694 } 2695 2696 var buff [1024]byte 2697 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2698 2699 body := io.TeeReader(errorBody, ringBuffer) 2700 decoder := json.NewDecoder(body) 2701 decoder.UseNumber() 2702 code, message, err := restjson.GetErrorInfo(decoder) 2703 if err != nil { 2704 var snapshot bytes.Buffer 2705 io.Copy(&snapshot, ringBuffer) 2706 err = &smithy.DeserializationError{ 2707 Err: fmt.Errorf("failed to decode response body, %w", err), 2708 Snapshot: snapshot.Bytes(), 2709 } 2710 return err 2711 } 2712 2713 errorBody.Seek(0, io.SeekStart) 2714 if len(code) != 0 { 2715 errorCode = restjson.SanitizeErrorCode(code) 2716 } 2717 if len(message) != 0 { 2718 errorMessage = message 2719 } 2720 2721 switch { 2722 case strings.EqualFold("BadRequestException", errorCode): 2723 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 2724 2725 case strings.EqualFold("ConflictException", errorCode): 2726 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 2727 2728 case strings.EqualFold("InternalFailureException", errorCode): 2729 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 2730 2731 case strings.EqualFold("LimitExceededException", errorCode): 2732 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 2733 2734 default: 2735 genericError := &smithy.GenericAPIError{ 2736 Code: errorCode, 2737 Message: errorMessage, 2738 } 2739 return genericError 2740 2741 } 2742} 2743 2744type awsAwsjson11_deserializeOpUpdateMedicalVocabulary struct { 2745} 2746 2747func (*awsAwsjson11_deserializeOpUpdateMedicalVocabulary) ID() string { 2748 return "OperationDeserializer" 2749} 2750 2751func (m *awsAwsjson11_deserializeOpUpdateMedicalVocabulary) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2752 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2753) { 2754 out, metadata, err = next.HandleDeserialize(ctx, in) 2755 if err != nil { 2756 return out, metadata, err 2757 } 2758 2759 response, ok := out.RawResponse.(*smithyhttp.Response) 2760 if !ok { 2761 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2762 } 2763 2764 if response.StatusCode < 200 || response.StatusCode >= 300 { 2765 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateMedicalVocabulary(response, &metadata) 2766 } 2767 output := &UpdateMedicalVocabularyOutput{} 2768 out.Result = output 2769 2770 var buff [1024]byte 2771 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2772 2773 body := io.TeeReader(response.Body, ringBuffer) 2774 decoder := json.NewDecoder(body) 2775 decoder.UseNumber() 2776 var shape interface{} 2777 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2778 var snapshot bytes.Buffer 2779 io.Copy(&snapshot, ringBuffer) 2780 err = &smithy.DeserializationError{ 2781 Err: fmt.Errorf("failed to decode response body, %w", err), 2782 Snapshot: snapshot.Bytes(), 2783 } 2784 return out, metadata, err 2785 } 2786 2787 err = awsAwsjson11_deserializeOpDocumentUpdateMedicalVocabularyOutput(&output, shape) 2788 if err != nil { 2789 var snapshot bytes.Buffer 2790 io.Copy(&snapshot, ringBuffer) 2791 err = &smithy.DeserializationError{ 2792 Err: fmt.Errorf("failed to decode response body, %w", err), 2793 Snapshot: snapshot.Bytes(), 2794 } 2795 return out, metadata, err 2796 } 2797 2798 return out, metadata, err 2799} 2800 2801func awsAwsjson11_deserializeOpErrorUpdateMedicalVocabulary(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2802 var errorBuffer bytes.Buffer 2803 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2804 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2805 } 2806 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2807 2808 errorCode := "UnknownError" 2809 errorMessage := errorCode 2810 2811 code := response.Header.Get("X-Amzn-ErrorType") 2812 if len(code) != 0 { 2813 errorCode = restjson.SanitizeErrorCode(code) 2814 } 2815 2816 var buff [1024]byte 2817 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2818 2819 body := io.TeeReader(errorBody, ringBuffer) 2820 decoder := json.NewDecoder(body) 2821 decoder.UseNumber() 2822 code, message, err := restjson.GetErrorInfo(decoder) 2823 if err != nil { 2824 var snapshot bytes.Buffer 2825 io.Copy(&snapshot, ringBuffer) 2826 err = &smithy.DeserializationError{ 2827 Err: fmt.Errorf("failed to decode response body, %w", err), 2828 Snapshot: snapshot.Bytes(), 2829 } 2830 return err 2831 } 2832 2833 errorBody.Seek(0, io.SeekStart) 2834 if len(code) != 0 { 2835 errorCode = restjson.SanitizeErrorCode(code) 2836 } 2837 if len(message) != 0 { 2838 errorMessage = message 2839 } 2840 2841 switch { 2842 case strings.EqualFold("BadRequestException", errorCode): 2843 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 2844 2845 case strings.EqualFold("ConflictException", errorCode): 2846 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 2847 2848 case strings.EqualFold("InternalFailureException", errorCode): 2849 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 2850 2851 case strings.EqualFold("LimitExceededException", errorCode): 2852 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 2853 2854 case strings.EqualFold("NotFoundException", errorCode): 2855 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody) 2856 2857 default: 2858 genericError := &smithy.GenericAPIError{ 2859 Code: errorCode, 2860 Message: errorMessage, 2861 } 2862 return genericError 2863 2864 } 2865} 2866 2867type awsAwsjson11_deserializeOpUpdateVocabulary struct { 2868} 2869 2870func (*awsAwsjson11_deserializeOpUpdateVocabulary) ID() string { 2871 return "OperationDeserializer" 2872} 2873 2874func (m *awsAwsjson11_deserializeOpUpdateVocabulary) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2875 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2876) { 2877 out, metadata, err = next.HandleDeserialize(ctx, in) 2878 if err != nil { 2879 return out, metadata, err 2880 } 2881 2882 response, ok := out.RawResponse.(*smithyhttp.Response) 2883 if !ok { 2884 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2885 } 2886 2887 if response.StatusCode < 200 || response.StatusCode >= 300 { 2888 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateVocabulary(response, &metadata) 2889 } 2890 output := &UpdateVocabularyOutput{} 2891 out.Result = output 2892 2893 var buff [1024]byte 2894 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2895 2896 body := io.TeeReader(response.Body, ringBuffer) 2897 decoder := json.NewDecoder(body) 2898 decoder.UseNumber() 2899 var shape interface{} 2900 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2901 var snapshot bytes.Buffer 2902 io.Copy(&snapshot, ringBuffer) 2903 err = &smithy.DeserializationError{ 2904 Err: fmt.Errorf("failed to decode response body, %w", err), 2905 Snapshot: snapshot.Bytes(), 2906 } 2907 return out, metadata, err 2908 } 2909 2910 err = awsAwsjson11_deserializeOpDocumentUpdateVocabularyOutput(&output, shape) 2911 if err != nil { 2912 var snapshot bytes.Buffer 2913 io.Copy(&snapshot, ringBuffer) 2914 err = &smithy.DeserializationError{ 2915 Err: fmt.Errorf("failed to decode response body, %w", err), 2916 Snapshot: snapshot.Bytes(), 2917 } 2918 return out, metadata, err 2919 } 2920 2921 return out, metadata, err 2922} 2923 2924func awsAwsjson11_deserializeOpErrorUpdateVocabulary(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2925 var errorBuffer bytes.Buffer 2926 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2927 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2928 } 2929 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2930 2931 errorCode := "UnknownError" 2932 errorMessage := errorCode 2933 2934 code := response.Header.Get("X-Amzn-ErrorType") 2935 if len(code) != 0 { 2936 errorCode = restjson.SanitizeErrorCode(code) 2937 } 2938 2939 var buff [1024]byte 2940 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2941 2942 body := io.TeeReader(errorBody, ringBuffer) 2943 decoder := json.NewDecoder(body) 2944 decoder.UseNumber() 2945 code, message, err := restjson.GetErrorInfo(decoder) 2946 if err != nil { 2947 var snapshot bytes.Buffer 2948 io.Copy(&snapshot, ringBuffer) 2949 err = &smithy.DeserializationError{ 2950 Err: fmt.Errorf("failed to decode response body, %w", err), 2951 Snapshot: snapshot.Bytes(), 2952 } 2953 return err 2954 } 2955 2956 errorBody.Seek(0, io.SeekStart) 2957 if len(code) != 0 { 2958 errorCode = restjson.SanitizeErrorCode(code) 2959 } 2960 if len(message) != 0 { 2961 errorMessage = message 2962 } 2963 2964 switch { 2965 case strings.EqualFold("BadRequestException", errorCode): 2966 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 2967 2968 case strings.EqualFold("ConflictException", errorCode): 2969 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 2970 2971 case strings.EqualFold("InternalFailureException", errorCode): 2972 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 2973 2974 case strings.EqualFold("LimitExceededException", errorCode): 2975 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 2976 2977 case strings.EqualFold("NotFoundException", errorCode): 2978 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody) 2979 2980 default: 2981 genericError := &smithy.GenericAPIError{ 2982 Code: errorCode, 2983 Message: errorMessage, 2984 } 2985 return genericError 2986 2987 } 2988} 2989 2990type awsAwsjson11_deserializeOpUpdateVocabularyFilter struct { 2991} 2992 2993func (*awsAwsjson11_deserializeOpUpdateVocabularyFilter) ID() string { 2994 return "OperationDeserializer" 2995} 2996 2997func (m *awsAwsjson11_deserializeOpUpdateVocabularyFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2998 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2999) { 3000 out, metadata, err = next.HandleDeserialize(ctx, in) 3001 if err != nil { 3002 return out, metadata, err 3003 } 3004 3005 response, ok := out.RawResponse.(*smithyhttp.Response) 3006 if !ok { 3007 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3008 } 3009 3010 if response.StatusCode < 200 || response.StatusCode >= 300 { 3011 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateVocabularyFilter(response, &metadata) 3012 } 3013 output := &UpdateVocabularyFilterOutput{} 3014 out.Result = output 3015 3016 var buff [1024]byte 3017 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3018 3019 body := io.TeeReader(response.Body, ringBuffer) 3020 decoder := json.NewDecoder(body) 3021 decoder.UseNumber() 3022 var shape interface{} 3023 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3024 var snapshot bytes.Buffer 3025 io.Copy(&snapshot, ringBuffer) 3026 err = &smithy.DeserializationError{ 3027 Err: fmt.Errorf("failed to decode response body, %w", err), 3028 Snapshot: snapshot.Bytes(), 3029 } 3030 return out, metadata, err 3031 } 3032 3033 err = awsAwsjson11_deserializeOpDocumentUpdateVocabularyFilterOutput(&output, shape) 3034 if err != nil { 3035 var snapshot bytes.Buffer 3036 io.Copy(&snapshot, ringBuffer) 3037 err = &smithy.DeserializationError{ 3038 Err: fmt.Errorf("failed to decode response body, %w", err), 3039 Snapshot: snapshot.Bytes(), 3040 } 3041 return out, metadata, err 3042 } 3043 3044 return out, metadata, err 3045} 3046 3047func awsAwsjson11_deserializeOpErrorUpdateVocabularyFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3048 var errorBuffer bytes.Buffer 3049 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3050 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3051 } 3052 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3053 3054 errorCode := "UnknownError" 3055 errorMessage := errorCode 3056 3057 code := response.Header.Get("X-Amzn-ErrorType") 3058 if len(code) != 0 { 3059 errorCode = restjson.SanitizeErrorCode(code) 3060 } 3061 3062 var buff [1024]byte 3063 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3064 3065 body := io.TeeReader(errorBody, ringBuffer) 3066 decoder := json.NewDecoder(body) 3067 decoder.UseNumber() 3068 code, message, err := restjson.GetErrorInfo(decoder) 3069 if err != nil { 3070 var snapshot bytes.Buffer 3071 io.Copy(&snapshot, ringBuffer) 3072 err = &smithy.DeserializationError{ 3073 Err: fmt.Errorf("failed to decode response body, %w", err), 3074 Snapshot: snapshot.Bytes(), 3075 } 3076 return err 3077 } 3078 3079 errorBody.Seek(0, io.SeekStart) 3080 if len(code) != 0 { 3081 errorCode = restjson.SanitizeErrorCode(code) 3082 } 3083 if len(message) != 0 { 3084 errorMessage = message 3085 } 3086 3087 switch { 3088 case strings.EqualFold("BadRequestException", errorCode): 3089 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 3090 3091 case strings.EqualFold("InternalFailureException", errorCode): 3092 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 3093 3094 case strings.EqualFold("LimitExceededException", errorCode): 3095 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 3096 3097 case strings.EqualFold("NotFoundException", errorCode): 3098 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody) 3099 3100 default: 3101 genericError := &smithy.GenericAPIError{ 3102 Code: errorCode, 3103 Message: errorMessage, 3104 } 3105 return genericError 3106 3107 } 3108} 3109 3110func awsAwsjson11_deserializeErrorBadRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3111 var buff [1024]byte 3112 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3113 3114 body := io.TeeReader(errorBody, ringBuffer) 3115 decoder := json.NewDecoder(body) 3116 decoder.UseNumber() 3117 var shape interface{} 3118 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3119 var snapshot bytes.Buffer 3120 io.Copy(&snapshot, ringBuffer) 3121 err = &smithy.DeserializationError{ 3122 Err: fmt.Errorf("failed to decode response body, %w", err), 3123 Snapshot: snapshot.Bytes(), 3124 } 3125 return err 3126 } 3127 3128 output := &types.BadRequestException{} 3129 err := awsAwsjson11_deserializeDocumentBadRequestException(&output, shape) 3130 3131 if err != nil { 3132 var snapshot bytes.Buffer 3133 io.Copy(&snapshot, ringBuffer) 3134 err = &smithy.DeserializationError{ 3135 Err: fmt.Errorf("failed to decode response body, %w", err), 3136 Snapshot: snapshot.Bytes(), 3137 } 3138 return err 3139 } 3140 3141 errorBody.Seek(0, io.SeekStart) 3142 return output 3143} 3144 3145func awsAwsjson11_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3146 var buff [1024]byte 3147 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3148 3149 body := io.TeeReader(errorBody, ringBuffer) 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 err 3161 } 3162 3163 output := &types.ConflictException{} 3164 err := awsAwsjson11_deserializeDocumentConflictException(&output, shape) 3165 3166 if err != nil { 3167 var snapshot bytes.Buffer 3168 io.Copy(&snapshot, ringBuffer) 3169 err = &smithy.DeserializationError{ 3170 Err: fmt.Errorf("failed to decode response body, %w", err), 3171 Snapshot: snapshot.Bytes(), 3172 } 3173 return err 3174 } 3175 3176 errorBody.Seek(0, io.SeekStart) 3177 return output 3178} 3179 3180func awsAwsjson11_deserializeErrorInternalFailureException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3181 var buff [1024]byte 3182 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3183 3184 body := io.TeeReader(errorBody, ringBuffer) 3185 decoder := json.NewDecoder(body) 3186 decoder.UseNumber() 3187 var shape interface{} 3188 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3189 var snapshot bytes.Buffer 3190 io.Copy(&snapshot, ringBuffer) 3191 err = &smithy.DeserializationError{ 3192 Err: fmt.Errorf("failed to decode response body, %w", err), 3193 Snapshot: snapshot.Bytes(), 3194 } 3195 return err 3196 } 3197 3198 output := &types.InternalFailureException{} 3199 err := awsAwsjson11_deserializeDocumentInternalFailureException(&output, shape) 3200 3201 if err != nil { 3202 var snapshot bytes.Buffer 3203 io.Copy(&snapshot, ringBuffer) 3204 err = &smithy.DeserializationError{ 3205 Err: fmt.Errorf("failed to decode response body, %w", err), 3206 Snapshot: snapshot.Bytes(), 3207 } 3208 return err 3209 } 3210 3211 errorBody.Seek(0, io.SeekStart) 3212 return output 3213} 3214 3215func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3216 var buff [1024]byte 3217 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3218 3219 body := io.TeeReader(errorBody, ringBuffer) 3220 decoder := json.NewDecoder(body) 3221 decoder.UseNumber() 3222 var shape interface{} 3223 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3224 var snapshot bytes.Buffer 3225 io.Copy(&snapshot, ringBuffer) 3226 err = &smithy.DeserializationError{ 3227 Err: fmt.Errorf("failed to decode response body, %w", err), 3228 Snapshot: snapshot.Bytes(), 3229 } 3230 return err 3231 } 3232 3233 output := &types.LimitExceededException{} 3234 err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape) 3235 3236 if err != nil { 3237 var snapshot bytes.Buffer 3238 io.Copy(&snapshot, ringBuffer) 3239 err = &smithy.DeserializationError{ 3240 Err: fmt.Errorf("failed to decode response body, %w", err), 3241 Snapshot: snapshot.Bytes(), 3242 } 3243 return err 3244 } 3245 3246 errorBody.Seek(0, io.SeekStart) 3247 return output 3248} 3249 3250func awsAwsjson11_deserializeErrorNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3251 var buff [1024]byte 3252 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3253 3254 body := io.TeeReader(errorBody, ringBuffer) 3255 decoder := json.NewDecoder(body) 3256 decoder.UseNumber() 3257 var shape interface{} 3258 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3259 var snapshot bytes.Buffer 3260 io.Copy(&snapshot, ringBuffer) 3261 err = &smithy.DeserializationError{ 3262 Err: fmt.Errorf("failed to decode response body, %w", err), 3263 Snapshot: snapshot.Bytes(), 3264 } 3265 return err 3266 } 3267 3268 output := &types.NotFoundException{} 3269 err := awsAwsjson11_deserializeDocumentNotFoundException(&output, shape) 3270 3271 if err != nil { 3272 var snapshot bytes.Buffer 3273 io.Copy(&snapshot, ringBuffer) 3274 err = &smithy.DeserializationError{ 3275 Err: fmt.Errorf("failed to decode response body, %w", err), 3276 Snapshot: snapshot.Bytes(), 3277 } 3278 return err 3279 } 3280 3281 errorBody.Seek(0, io.SeekStart) 3282 return output 3283} 3284 3285func awsAwsjson11_deserializeDocumentBadRequestException(v **types.BadRequestException, value interface{}) error { 3286 if v == nil { 3287 return fmt.Errorf("unexpected nil of type %T", v) 3288 } 3289 if value == nil { 3290 return nil 3291 } 3292 3293 shape, ok := value.(map[string]interface{}) 3294 if !ok { 3295 return fmt.Errorf("unexpected JSON type %v", value) 3296 } 3297 3298 var sv *types.BadRequestException 3299 if *v == nil { 3300 sv = &types.BadRequestException{} 3301 } else { 3302 sv = *v 3303 } 3304 3305 for key, value := range shape { 3306 switch key { 3307 case "Message": 3308 if value != nil { 3309 jtv, ok := value.(string) 3310 if !ok { 3311 return fmt.Errorf("expected FailureReason to be of type string, got %T instead", value) 3312 } 3313 sv.Message = ptr.String(jtv) 3314 } 3315 3316 default: 3317 _, _ = key, value 3318 3319 } 3320 } 3321 *v = sv 3322 return nil 3323} 3324 3325func awsAwsjson11_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { 3326 if v == nil { 3327 return fmt.Errorf("unexpected nil of type %T", v) 3328 } 3329 if value == nil { 3330 return nil 3331 } 3332 3333 shape, ok := value.(map[string]interface{}) 3334 if !ok { 3335 return fmt.Errorf("unexpected JSON type %v", value) 3336 } 3337 3338 var sv *types.ConflictException 3339 if *v == nil { 3340 sv = &types.ConflictException{} 3341 } else { 3342 sv = *v 3343 } 3344 3345 for key, value := range shape { 3346 switch key { 3347 case "Message": 3348 if value != nil { 3349 jtv, ok := value.(string) 3350 if !ok { 3351 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3352 } 3353 sv.Message = ptr.String(jtv) 3354 } 3355 3356 default: 3357 _, _ = key, value 3358 3359 } 3360 } 3361 *v = sv 3362 return nil 3363} 3364 3365func awsAwsjson11_deserializeDocumentContentRedaction(v **types.ContentRedaction, value interface{}) error { 3366 if v == nil { 3367 return fmt.Errorf("unexpected nil of type %T", v) 3368 } 3369 if value == nil { 3370 return nil 3371 } 3372 3373 shape, ok := value.(map[string]interface{}) 3374 if !ok { 3375 return fmt.Errorf("unexpected JSON type %v", value) 3376 } 3377 3378 var sv *types.ContentRedaction 3379 if *v == nil { 3380 sv = &types.ContentRedaction{} 3381 } else { 3382 sv = *v 3383 } 3384 3385 for key, value := range shape { 3386 switch key { 3387 case "RedactionOutput": 3388 if value != nil { 3389 jtv, ok := value.(string) 3390 if !ok { 3391 return fmt.Errorf("expected RedactionOutput to be of type string, got %T instead", value) 3392 } 3393 sv.RedactionOutput = types.RedactionOutput(jtv) 3394 } 3395 3396 case "RedactionType": 3397 if value != nil { 3398 jtv, ok := value.(string) 3399 if !ok { 3400 return fmt.Errorf("expected RedactionType to be of type string, got %T instead", value) 3401 } 3402 sv.RedactionType = types.RedactionType(jtv) 3403 } 3404 3405 default: 3406 _, _ = key, value 3407 3408 } 3409 } 3410 *v = sv 3411 return nil 3412} 3413 3414func awsAwsjson11_deserializeDocumentInputDataConfig(v **types.InputDataConfig, value interface{}) error { 3415 if v == nil { 3416 return fmt.Errorf("unexpected nil of type %T", v) 3417 } 3418 if value == nil { 3419 return nil 3420 } 3421 3422 shape, ok := value.(map[string]interface{}) 3423 if !ok { 3424 return fmt.Errorf("unexpected JSON type %v", value) 3425 } 3426 3427 var sv *types.InputDataConfig 3428 if *v == nil { 3429 sv = &types.InputDataConfig{} 3430 } else { 3431 sv = *v 3432 } 3433 3434 for key, value := range shape { 3435 switch key { 3436 case "DataAccessRoleArn": 3437 if value != nil { 3438 jtv, ok := value.(string) 3439 if !ok { 3440 return fmt.Errorf("expected DataAccessRoleArn to be of type string, got %T instead", value) 3441 } 3442 sv.DataAccessRoleArn = ptr.String(jtv) 3443 } 3444 3445 case "S3Uri": 3446 if value != nil { 3447 jtv, ok := value.(string) 3448 if !ok { 3449 return fmt.Errorf("expected Uri to be of type string, got %T instead", value) 3450 } 3451 sv.S3Uri = ptr.String(jtv) 3452 } 3453 3454 case "TuningDataS3Uri": 3455 if value != nil { 3456 jtv, ok := value.(string) 3457 if !ok { 3458 return fmt.Errorf("expected Uri to be of type string, got %T instead", value) 3459 } 3460 sv.TuningDataS3Uri = ptr.String(jtv) 3461 } 3462 3463 default: 3464 _, _ = key, value 3465 3466 } 3467 } 3468 *v = sv 3469 return nil 3470} 3471 3472func awsAwsjson11_deserializeDocumentInternalFailureException(v **types.InternalFailureException, value interface{}) error { 3473 if v == nil { 3474 return fmt.Errorf("unexpected nil of type %T", v) 3475 } 3476 if value == nil { 3477 return nil 3478 } 3479 3480 shape, ok := value.(map[string]interface{}) 3481 if !ok { 3482 return fmt.Errorf("unexpected JSON type %v", value) 3483 } 3484 3485 var sv *types.InternalFailureException 3486 if *v == nil { 3487 sv = &types.InternalFailureException{} 3488 } else { 3489 sv = *v 3490 } 3491 3492 for key, value := range shape { 3493 switch key { 3494 case "Message": 3495 if value != nil { 3496 jtv, ok := value.(string) 3497 if !ok { 3498 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3499 } 3500 sv.Message = ptr.String(jtv) 3501 } 3502 3503 default: 3504 _, _ = key, value 3505 3506 } 3507 } 3508 *v = sv 3509 return nil 3510} 3511 3512func awsAwsjson11_deserializeDocumentJobExecutionSettings(v **types.JobExecutionSettings, value interface{}) error { 3513 if v == nil { 3514 return fmt.Errorf("unexpected nil of type %T", v) 3515 } 3516 if value == nil { 3517 return nil 3518 } 3519 3520 shape, ok := value.(map[string]interface{}) 3521 if !ok { 3522 return fmt.Errorf("unexpected JSON type %v", value) 3523 } 3524 3525 var sv *types.JobExecutionSettings 3526 if *v == nil { 3527 sv = &types.JobExecutionSettings{} 3528 } else { 3529 sv = *v 3530 } 3531 3532 for key, value := range shape { 3533 switch key { 3534 case "AllowDeferredExecution": 3535 if value != nil { 3536 jtv, ok := value.(bool) 3537 if !ok { 3538 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 3539 } 3540 sv.AllowDeferredExecution = ptr.Bool(jtv) 3541 } 3542 3543 case "DataAccessRoleArn": 3544 if value != nil { 3545 jtv, ok := value.(string) 3546 if !ok { 3547 return fmt.Errorf("expected DataAccessRoleArn to be of type string, got %T instead", value) 3548 } 3549 sv.DataAccessRoleArn = ptr.String(jtv) 3550 } 3551 3552 default: 3553 _, _ = key, value 3554 3555 } 3556 } 3557 *v = sv 3558 return nil 3559} 3560 3561func awsAwsjson11_deserializeDocumentLanguageModel(v **types.LanguageModel, value interface{}) error { 3562 if v == nil { 3563 return fmt.Errorf("unexpected nil of type %T", v) 3564 } 3565 if value == nil { 3566 return nil 3567 } 3568 3569 shape, ok := value.(map[string]interface{}) 3570 if !ok { 3571 return fmt.Errorf("unexpected JSON type %v", value) 3572 } 3573 3574 var sv *types.LanguageModel 3575 if *v == nil { 3576 sv = &types.LanguageModel{} 3577 } else { 3578 sv = *v 3579 } 3580 3581 for key, value := range shape { 3582 switch key { 3583 case "BaseModelName": 3584 if value != nil { 3585 jtv, ok := value.(string) 3586 if !ok { 3587 return fmt.Errorf("expected BaseModelName to be of type string, got %T instead", value) 3588 } 3589 sv.BaseModelName = types.BaseModelName(jtv) 3590 } 3591 3592 case "CreateTime": 3593 if value != nil { 3594 jtv, ok := value.(json.Number) 3595 if !ok { 3596 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 3597 } 3598 f64, err := jtv.Float64() 3599 if err != nil { 3600 return err 3601 } 3602 sv.CreateTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3603 } 3604 3605 case "FailureReason": 3606 if value != nil { 3607 jtv, ok := value.(string) 3608 if !ok { 3609 return fmt.Errorf("expected FailureReason to be of type string, got %T instead", value) 3610 } 3611 sv.FailureReason = ptr.String(jtv) 3612 } 3613 3614 case "InputDataConfig": 3615 if err := awsAwsjson11_deserializeDocumentInputDataConfig(&sv.InputDataConfig, value); err != nil { 3616 return err 3617 } 3618 3619 case "LanguageCode": 3620 if value != nil { 3621 jtv, ok := value.(string) 3622 if !ok { 3623 return fmt.Errorf("expected CLMLanguageCode to be of type string, got %T instead", value) 3624 } 3625 sv.LanguageCode = types.CLMLanguageCode(jtv) 3626 } 3627 3628 case "LastModifiedTime": 3629 if value != nil { 3630 jtv, ok := value.(json.Number) 3631 if !ok { 3632 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 3633 } 3634 f64, err := jtv.Float64() 3635 if err != nil { 3636 return err 3637 } 3638 sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3639 } 3640 3641 case "ModelName": 3642 if value != nil { 3643 jtv, ok := value.(string) 3644 if !ok { 3645 return fmt.Errorf("expected ModelName to be of type string, got %T instead", value) 3646 } 3647 sv.ModelName = ptr.String(jtv) 3648 } 3649 3650 case "ModelStatus": 3651 if value != nil { 3652 jtv, ok := value.(string) 3653 if !ok { 3654 return fmt.Errorf("expected ModelStatus to be of type string, got %T instead", value) 3655 } 3656 sv.ModelStatus = types.ModelStatus(jtv) 3657 } 3658 3659 case "UpgradeAvailability": 3660 if value != nil { 3661 jtv, ok := value.(bool) 3662 if !ok { 3663 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 3664 } 3665 sv.UpgradeAvailability = ptr.Bool(jtv) 3666 } 3667 3668 default: 3669 _, _ = key, value 3670 3671 } 3672 } 3673 *v = sv 3674 return nil 3675} 3676 3677func awsAwsjson11_deserializeDocumentLanguageOptions(v *[]types.LanguageCode, value interface{}) error { 3678 if v == nil { 3679 return fmt.Errorf("unexpected nil of type %T", v) 3680 } 3681 if value == nil { 3682 return nil 3683 } 3684 3685 shape, ok := value.([]interface{}) 3686 if !ok { 3687 return fmt.Errorf("unexpected JSON type %v", value) 3688 } 3689 3690 var cv []types.LanguageCode 3691 if *v == nil { 3692 cv = []types.LanguageCode{} 3693 } else { 3694 cv = *v 3695 } 3696 3697 for _, value := range shape { 3698 var col types.LanguageCode 3699 if value != nil { 3700 jtv, ok := value.(string) 3701 if !ok { 3702 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 3703 } 3704 col = types.LanguageCode(jtv) 3705 } 3706 cv = append(cv, col) 3707 3708 } 3709 *v = cv 3710 return nil 3711} 3712 3713func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { 3714 if v == nil { 3715 return fmt.Errorf("unexpected nil of type %T", v) 3716 } 3717 if value == nil { 3718 return nil 3719 } 3720 3721 shape, ok := value.(map[string]interface{}) 3722 if !ok { 3723 return fmt.Errorf("unexpected JSON type %v", value) 3724 } 3725 3726 var sv *types.LimitExceededException 3727 if *v == nil { 3728 sv = &types.LimitExceededException{} 3729 } else { 3730 sv = *v 3731 } 3732 3733 for key, value := range shape { 3734 switch key { 3735 case "Message": 3736 if value != nil { 3737 jtv, ok := value.(string) 3738 if !ok { 3739 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3740 } 3741 sv.Message = ptr.String(jtv) 3742 } 3743 3744 default: 3745 _, _ = key, value 3746 3747 } 3748 } 3749 *v = sv 3750 return nil 3751} 3752 3753func awsAwsjson11_deserializeDocumentMedia(v **types.Media, value interface{}) error { 3754 if v == nil { 3755 return fmt.Errorf("unexpected nil of type %T", v) 3756 } 3757 if value == nil { 3758 return nil 3759 } 3760 3761 shape, ok := value.(map[string]interface{}) 3762 if !ok { 3763 return fmt.Errorf("unexpected JSON type %v", value) 3764 } 3765 3766 var sv *types.Media 3767 if *v == nil { 3768 sv = &types.Media{} 3769 } else { 3770 sv = *v 3771 } 3772 3773 for key, value := range shape { 3774 switch key { 3775 case "MediaFileUri": 3776 if value != nil { 3777 jtv, ok := value.(string) 3778 if !ok { 3779 return fmt.Errorf("expected Uri to be of type string, got %T instead", value) 3780 } 3781 sv.MediaFileUri = ptr.String(jtv) 3782 } 3783 3784 default: 3785 _, _ = key, value 3786 3787 } 3788 } 3789 *v = sv 3790 return nil 3791} 3792 3793func awsAwsjson11_deserializeDocumentMedicalTranscript(v **types.MedicalTranscript, value interface{}) error { 3794 if v == nil { 3795 return fmt.Errorf("unexpected nil of type %T", v) 3796 } 3797 if value == nil { 3798 return nil 3799 } 3800 3801 shape, ok := value.(map[string]interface{}) 3802 if !ok { 3803 return fmt.Errorf("unexpected JSON type %v", value) 3804 } 3805 3806 var sv *types.MedicalTranscript 3807 if *v == nil { 3808 sv = &types.MedicalTranscript{} 3809 } else { 3810 sv = *v 3811 } 3812 3813 for key, value := range shape { 3814 switch key { 3815 case "TranscriptFileUri": 3816 if value != nil { 3817 jtv, ok := value.(string) 3818 if !ok { 3819 return fmt.Errorf("expected Uri to be of type string, got %T instead", value) 3820 } 3821 sv.TranscriptFileUri = ptr.String(jtv) 3822 } 3823 3824 default: 3825 _, _ = key, value 3826 3827 } 3828 } 3829 *v = sv 3830 return nil 3831} 3832 3833func awsAwsjson11_deserializeDocumentMedicalTranscriptionJob(v **types.MedicalTranscriptionJob, value interface{}) error { 3834 if v == nil { 3835 return fmt.Errorf("unexpected nil of type %T", v) 3836 } 3837 if value == nil { 3838 return nil 3839 } 3840 3841 shape, ok := value.(map[string]interface{}) 3842 if !ok { 3843 return fmt.Errorf("unexpected JSON type %v", value) 3844 } 3845 3846 var sv *types.MedicalTranscriptionJob 3847 if *v == nil { 3848 sv = &types.MedicalTranscriptionJob{} 3849 } else { 3850 sv = *v 3851 } 3852 3853 for key, value := range shape { 3854 switch key { 3855 case "CompletionTime": 3856 if value != nil { 3857 jtv, ok := value.(json.Number) 3858 if !ok { 3859 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 3860 } 3861 f64, err := jtv.Float64() 3862 if err != nil { 3863 return err 3864 } 3865 sv.CompletionTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3866 } 3867 3868 case "CreationTime": 3869 if value != nil { 3870 jtv, ok := value.(json.Number) 3871 if !ok { 3872 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 3873 } 3874 f64, err := jtv.Float64() 3875 if err != nil { 3876 return err 3877 } 3878 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3879 } 3880 3881 case "FailureReason": 3882 if value != nil { 3883 jtv, ok := value.(string) 3884 if !ok { 3885 return fmt.Errorf("expected FailureReason to be of type string, got %T instead", value) 3886 } 3887 sv.FailureReason = ptr.String(jtv) 3888 } 3889 3890 case "LanguageCode": 3891 if value != nil { 3892 jtv, ok := value.(string) 3893 if !ok { 3894 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 3895 } 3896 sv.LanguageCode = types.LanguageCode(jtv) 3897 } 3898 3899 case "Media": 3900 if err := awsAwsjson11_deserializeDocumentMedia(&sv.Media, value); err != nil { 3901 return err 3902 } 3903 3904 case "MediaFormat": 3905 if value != nil { 3906 jtv, ok := value.(string) 3907 if !ok { 3908 return fmt.Errorf("expected MediaFormat to be of type string, got %T instead", value) 3909 } 3910 sv.MediaFormat = types.MediaFormat(jtv) 3911 } 3912 3913 case "MediaSampleRateHertz": 3914 if value != nil { 3915 jtv, ok := value.(json.Number) 3916 if !ok { 3917 return fmt.Errorf("expected MediaSampleRateHertz to be json.Number, got %T instead", value) 3918 } 3919 i64, err := jtv.Int64() 3920 if err != nil { 3921 return err 3922 } 3923 sv.MediaSampleRateHertz = ptr.Int32(int32(i64)) 3924 } 3925 3926 case "MedicalTranscriptionJobName": 3927 if value != nil { 3928 jtv, ok := value.(string) 3929 if !ok { 3930 return fmt.Errorf("expected TranscriptionJobName to be of type string, got %T instead", value) 3931 } 3932 sv.MedicalTranscriptionJobName = ptr.String(jtv) 3933 } 3934 3935 case "Settings": 3936 if err := awsAwsjson11_deserializeDocumentMedicalTranscriptionSetting(&sv.Settings, value); err != nil { 3937 return err 3938 } 3939 3940 case "Specialty": 3941 if value != nil { 3942 jtv, ok := value.(string) 3943 if !ok { 3944 return fmt.Errorf("expected Specialty to be of type string, got %T instead", value) 3945 } 3946 sv.Specialty = types.Specialty(jtv) 3947 } 3948 3949 case "StartTime": 3950 if value != nil { 3951 jtv, ok := value.(json.Number) 3952 if !ok { 3953 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 3954 } 3955 f64, err := jtv.Float64() 3956 if err != nil { 3957 return err 3958 } 3959 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3960 } 3961 3962 case "Transcript": 3963 if err := awsAwsjson11_deserializeDocumentMedicalTranscript(&sv.Transcript, value); err != nil { 3964 return err 3965 } 3966 3967 case "TranscriptionJobStatus": 3968 if value != nil { 3969 jtv, ok := value.(string) 3970 if !ok { 3971 return fmt.Errorf("expected TranscriptionJobStatus to be of type string, got %T instead", value) 3972 } 3973 sv.TranscriptionJobStatus = types.TranscriptionJobStatus(jtv) 3974 } 3975 3976 case "Type": 3977 if value != nil { 3978 jtv, ok := value.(string) 3979 if !ok { 3980 return fmt.Errorf("expected Type to be of type string, got %T instead", value) 3981 } 3982 sv.Type = types.Type(jtv) 3983 } 3984 3985 default: 3986 _, _ = key, value 3987 3988 } 3989 } 3990 *v = sv 3991 return nil 3992} 3993 3994func awsAwsjson11_deserializeDocumentMedicalTranscriptionJobSummaries(v *[]types.MedicalTranscriptionJobSummary, value interface{}) error { 3995 if v == nil { 3996 return fmt.Errorf("unexpected nil of type %T", v) 3997 } 3998 if value == nil { 3999 return nil 4000 } 4001 4002 shape, ok := value.([]interface{}) 4003 if !ok { 4004 return fmt.Errorf("unexpected JSON type %v", value) 4005 } 4006 4007 var cv []types.MedicalTranscriptionJobSummary 4008 if *v == nil { 4009 cv = []types.MedicalTranscriptionJobSummary{} 4010 } else { 4011 cv = *v 4012 } 4013 4014 for _, value := range shape { 4015 var col types.MedicalTranscriptionJobSummary 4016 destAddr := &col 4017 if err := awsAwsjson11_deserializeDocumentMedicalTranscriptionJobSummary(&destAddr, value); err != nil { 4018 return err 4019 } 4020 col = *destAddr 4021 cv = append(cv, col) 4022 4023 } 4024 *v = cv 4025 return nil 4026} 4027 4028func awsAwsjson11_deserializeDocumentMedicalTranscriptionJobSummary(v **types.MedicalTranscriptionJobSummary, value interface{}) error { 4029 if v == nil { 4030 return fmt.Errorf("unexpected nil of type %T", v) 4031 } 4032 if value == nil { 4033 return nil 4034 } 4035 4036 shape, ok := value.(map[string]interface{}) 4037 if !ok { 4038 return fmt.Errorf("unexpected JSON type %v", value) 4039 } 4040 4041 var sv *types.MedicalTranscriptionJobSummary 4042 if *v == nil { 4043 sv = &types.MedicalTranscriptionJobSummary{} 4044 } else { 4045 sv = *v 4046 } 4047 4048 for key, value := range shape { 4049 switch key { 4050 case "CompletionTime": 4051 if value != nil { 4052 jtv, ok := value.(json.Number) 4053 if !ok { 4054 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 4055 } 4056 f64, err := jtv.Float64() 4057 if err != nil { 4058 return err 4059 } 4060 sv.CompletionTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4061 } 4062 4063 case "CreationTime": 4064 if value != nil { 4065 jtv, ok := value.(json.Number) 4066 if !ok { 4067 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 4068 } 4069 f64, err := jtv.Float64() 4070 if err != nil { 4071 return err 4072 } 4073 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4074 } 4075 4076 case "FailureReason": 4077 if value != nil { 4078 jtv, ok := value.(string) 4079 if !ok { 4080 return fmt.Errorf("expected FailureReason to be of type string, got %T instead", value) 4081 } 4082 sv.FailureReason = ptr.String(jtv) 4083 } 4084 4085 case "LanguageCode": 4086 if value != nil { 4087 jtv, ok := value.(string) 4088 if !ok { 4089 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 4090 } 4091 sv.LanguageCode = types.LanguageCode(jtv) 4092 } 4093 4094 case "MedicalTranscriptionJobName": 4095 if value != nil { 4096 jtv, ok := value.(string) 4097 if !ok { 4098 return fmt.Errorf("expected TranscriptionJobName to be of type string, got %T instead", value) 4099 } 4100 sv.MedicalTranscriptionJobName = ptr.String(jtv) 4101 } 4102 4103 case "OutputLocationType": 4104 if value != nil { 4105 jtv, ok := value.(string) 4106 if !ok { 4107 return fmt.Errorf("expected OutputLocationType to be of type string, got %T instead", value) 4108 } 4109 sv.OutputLocationType = types.OutputLocationType(jtv) 4110 } 4111 4112 case "Specialty": 4113 if value != nil { 4114 jtv, ok := value.(string) 4115 if !ok { 4116 return fmt.Errorf("expected Specialty to be of type string, got %T instead", value) 4117 } 4118 sv.Specialty = types.Specialty(jtv) 4119 } 4120 4121 case "StartTime": 4122 if value != nil { 4123 jtv, ok := value.(json.Number) 4124 if !ok { 4125 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 4126 } 4127 f64, err := jtv.Float64() 4128 if err != nil { 4129 return err 4130 } 4131 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4132 } 4133 4134 case "TranscriptionJobStatus": 4135 if value != nil { 4136 jtv, ok := value.(string) 4137 if !ok { 4138 return fmt.Errorf("expected TranscriptionJobStatus to be of type string, got %T instead", value) 4139 } 4140 sv.TranscriptionJobStatus = types.TranscriptionJobStatus(jtv) 4141 } 4142 4143 case "Type": 4144 if value != nil { 4145 jtv, ok := value.(string) 4146 if !ok { 4147 return fmt.Errorf("expected Type to be of type string, got %T instead", value) 4148 } 4149 sv.Type = types.Type(jtv) 4150 } 4151 4152 default: 4153 _, _ = key, value 4154 4155 } 4156 } 4157 *v = sv 4158 return nil 4159} 4160 4161func awsAwsjson11_deserializeDocumentMedicalTranscriptionSetting(v **types.MedicalTranscriptionSetting, value interface{}) error { 4162 if v == nil { 4163 return fmt.Errorf("unexpected nil of type %T", v) 4164 } 4165 if value == nil { 4166 return nil 4167 } 4168 4169 shape, ok := value.(map[string]interface{}) 4170 if !ok { 4171 return fmt.Errorf("unexpected JSON type %v", value) 4172 } 4173 4174 var sv *types.MedicalTranscriptionSetting 4175 if *v == nil { 4176 sv = &types.MedicalTranscriptionSetting{} 4177 } else { 4178 sv = *v 4179 } 4180 4181 for key, value := range shape { 4182 switch key { 4183 case "ChannelIdentification": 4184 if value != nil { 4185 jtv, ok := value.(bool) 4186 if !ok { 4187 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 4188 } 4189 sv.ChannelIdentification = ptr.Bool(jtv) 4190 } 4191 4192 case "MaxAlternatives": 4193 if value != nil { 4194 jtv, ok := value.(json.Number) 4195 if !ok { 4196 return fmt.Errorf("expected MaxAlternatives to be json.Number, got %T instead", value) 4197 } 4198 i64, err := jtv.Int64() 4199 if err != nil { 4200 return err 4201 } 4202 sv.MaxAlternatives = ptr.Int32(int32(i64)) 4203 } 4204 4205 case "MaxSpeakerLabels": 4206 if value != nil { 4207 jtv, ok := value.(json.Number) 4208 if !ok { 4209 return fmt.Errorf("expected MaxSpeakers to be json.Number, got %T instead", value) 4210 } 4211 i64, err := jtv.Int64() 4212 if err != nil { 4213 return err 4214 } 4215 sv.MaxSpeakerLabels = ptr.Int32(int32(i64)) 4216 } 4217 4218 case "ShowAlternatives": 4219 if value != nil { 4220 jtv, ok := value.(bool) 4221 if !ok { 4222 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 4223 } 4224 sv.ShowAlternatives = ptr.Bool(jtv) 4225 } 4226 4227 case "ShowSpeakerLabels": 4228 if value != nil { 4229 jtv, ok := value.(bool) 4230 if !ok { 4231 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 4232 } 4233 sv.ShowSpeakerLabels = ptr.Bool(jtv) 4234 } 4235 4236 case "VocabularyName": 4237 if value != nil { 4238 jtv, ok := value.(string) 4239 if !ok { 4240 return fmt.Errorf("expected VocabularyName to be of type string, got %T instead", value) 4241 } 4242 sv.VocabularyName = ptr.String(jtv) 4243 } 4244 4245 default: 4246 _, _ = key, value 4247 4248 } 4249 } 4250 *v = sv 4251 return nil 4252} 4253 4254func awsAwsjson11_deserializeDocumentModels(v *[]types.LanguageModel, value interface{}) error { 4255 if v == nil { 4256 return fmt.Errorf("unexpected nil of type %T", v) 4257 } 4258 if value == nil { 4259 return nil 4260 } 4261 4262 shape, ok := value.([]interface{}) 4263 if !ok { 4264 return fmt.Errorf("unexpected JSON type %v", value) 4265 } 4266 4267 var cv []types.LanguageModel 4268 if *v == nil { 4269 cv = []types.LanguageModel{} 4270 } else { 4271 cv = *v 4272 } 4273 4274 for _, value := range shape { 4275 var col types.LanguageModel 4276 destAddr := &col 4277 if err := awsAwsjson11_deserializeDocumentLanguageModel(&destAddr, value); err != nil { 4278 return err 4279 } 4280 col = *destAddr 4281 cv = append(cv, col) 4282 4283 } 4284 *v = cv 4285 return nil 4286} 4287 4288func awsAwsjson11_deserializeDocumentModelSettings(v **types.ModelSettings, value interface{}) error { 4289 if v == nil { 4290 return fmt.Errorf("unexpected nil of type %T", v) 4291 } 4292 if value == nil { 4293 return nil 4294 } 4295 4296 shape, ok := value.(map[string]interface{}) 4297 if !ok { 4298 return fmt.Errorf("unexpected JSON type %v", value) 4299 } 4300 4301 var sv *types.ModelSettings 4302 if *v == nil { 4303 sv = &types.ModelSettings{} 4304 } else { 4305 sv = *v 4306 } 4307 4308 for key, value := range shape { 4309 switch key { 4310 case "LanguageModelName": 4311 if value != nil { 4312 jtv, ok := value.(string) 4313 if !ok { 4314 return fmt.Errorf("expected ModelName to be of type string, got %T instead", value) 4315 } 4316 sv.LanguageModelName = ptr.String(jtv) 4317 } 4318 4319 default: 4320 _, _ = key, value 4321 4322 } 4323 } 4324 *v = sv 4325 return nil 4326} 4327 4328func awsAwsjson11_deserializeDocumentNotFoundException(v **types.NotFoundException, value interface{}) error { 4329 if v == nil { 4330 return fmt.Errorf("unexpected nil of type %T", v) 4331 } 4332 if value == nil { 4333 return nil 4334 } 4335 4336 shape, ok := value.(map[string]interface{}) 4337 if !ok { 4338 return fmt.Errorf("unexpected JSON type %v", value) 4339 } 4340 4341 var sv *types.NotFoundException 4342 if *v == nil { 4343 sv = &types.NotFoundException{} 4344 } else { 4345 sv = *v 4346 } 4347 4348 for key, value := range shape { 4349 switch key { 4350 case "Message": 4351 if value != nil { 4352 jtv, ok := value.(string) 4353 if !ok { 4354 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4355 } 4356 sv.Message = ptr.String(jtv) 4357 } 4358 4359 default: 4360 _, _ = key, value 4361 4362 } 4363 } 4364 *v = sv 4365 return nil 4366} 4367 4368func awsAwsjson11_deserializeDocumentSettings(v **types.Settings, value interface{}) error { 4369 if v == nil { 4370 return fmt.Errorf("unexpected nil of type %T", v) 4371 } 4372 if value == nil { 4373 return nil 4374 } 4375 4376 shape, ok := value.(map[string]interface{}) 4377 if !ok { 4378 return fmt.Errorf("unexpected JSON type %v", value) 4379 } 4380 4381 var sv *types.Settings 4382 if *v == nil { 4383 sv = &types.Settings{} 4384 } else { 4385 sv = *v 4386 } 4387 4388 for key, value := range shape { 4389 switch key { 4390 case "ChannelIdentification": 4391 if value != nil { 4392 jtv, ok := value.(bool) 4393 if !ok { 4394 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 4395 } 4396 sv.ChannelIdentification = ptr.Bool(jtv) 4397 } 4398 4399 case "MaxAlternatives": 4400 if value != nil { 4401 jtv, ok := value.(json.Number) 4402 if !ok { 4403 return fmt.Errorf("expected MaxAlternatives to be json.Number, got %T instead", value) 4404 } 4405 i64, err := jtv.Int64() 4406 if err != nil { 4407 return err 4408 } 4409 sv.MaxAlternatives = ptr.Int32(int32(i64)) 4410 } 4411 4412 case "MaxSpeakerLabels": 4413 if value != nil { 4414 jtv, ok := value.(json.Number) 4415 if !ok { 4416 return fmt.Errorf("expected MaxSpeakers to be json.Number, got %T instead", value) 4417 } 4418 i64, err := jtv.Int64() 4419 if err != nil { 4420 return err 4421 } 4422 sv.MaxSpeakerLabels = ptr.Int32(int32(i64)) 4423 } 4424 4425 case "ShowAlternatives": 4426 if value != nil { 4427 jtv, ok := value.(bool) 4428 if !ok { 4429 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 4430 } 4431 sv.ShowAlternatives = ptr.Bool(jtv) 4432 } 4433 4434 case "ShowSpeakerLabels": 4435 if value != nil { 4436 jtv, ok := value.(bool) 4437 if !ok { 4438 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 4439 } 4440 sv.ShowSpeakerLabels = ptr.Bool(jtv) 4441 } 4442 4443 case "VocabularyFilterMethod": 4444 if value != nil { 4445 jtv, ok := value.(string) 4446 if !ok { 4447 return fmt.Errorf("expected VocabularyFilterMethod to be of type string, got %T instead", value) 4448 } 4449 sv.VocabularyFilterMethod = types.VocabularyFilterMethod(jtv) 4450 } 4451 4452 case "VocabularyFilterName": 4453 if value != nil { 4454 jtv, ok := value.(string) 4455 if !ok { 4456 return fmt.Errorf("expected VocabularyFilterName to be of type string, got %T instead", value) 4457 } 4458 sv.VocabularyFilterName = ptr.String(jtv) 4459 } 4460 4461 case "VocabularyName": 4462 if value != nil { 4463 jtv, ok := value.(string) 4464 if !ok { 4465 return fmt.Errorf("expected VocabularyName to be of type string, got %T instead", value) 4466 } 4467 sv.VocabularyName = ptr.String(jtv) 4468 } 4469 4470 default: 4471 _, _ = key, value 4472 4473 } 4474 } 4475 *v = sv 4476 return nil 4477} 4478 4479func awsAwsjson11_deserializeDocumentTranscript(v **types.Transcript, value interface{}) error { 4480 if v == nil { 4481 return fmt.Errorf("unexpected nil of type %T", v) 4482 } 4483 if value == nil { 4484 return nil 4485 } 4486 4487 shape, ok := value.(map[string]interface{}) 4488 if !ok { 4489 return fmt.Errorf("unexpected JSON type %v", value) 4490 } 4491 4492 var sv *types.Transcript 4493 if *v == nil { 4494 sv = &types.Transcript{} 4495 } else { 4496 sv = *v 4497 } 4498 4499 for key, value := range shape { 4500 switch key { 4501 case "RedactedTranscriptFileUri": 4502 if value != nil { 4503 jtv, ok := value.(string) 4504 if !ok { 4505 return fmt.Errorf("expected Uri to be of type string, got %T instead", value) 4506 } 4507 sv.RedactedTranscriptFileUri = ptr.String(jtv) 4508 } 4509 4510 case "TranscriptFileUri": 4511 if value != nil { 4512 jtv, ok := value.(string) 4513 if !ok { 4514 return fmt.Errorf("expected Uri to be of type string, got %T instead", value) 4515 } 4516 sv.TranscriptFileUri = ptr.String(jtv) 4517 } 4518 4519 default: 4520 _, _ = key, value 4521 4522 } 4523 } 4524 *v = sv 4525 return nil 4526} 4527 4528func awsAwsjson11_deserializeDocumentTranscriptionJob(v **types.TranscriptionJob, value interface{}) error { 4529 if v == nil { 4530 return fmt.Errorf("unexpected nil of type %T", v) 4531 } 4532 if value == nil { 4533 return nil 4534 } 4535 4536 shape, ok := value.(map[string]interface{}) 4537 if !ok { 4538 return fmt.Errorf("unexpected JSON type %v", value) 4539 } 4540 4541 var sv *types.TranscriptionJob 4542 if *v == nil { 4543 sv = &types.TranscriptionJob{} 4544 } else { 4545 sv = *v 4546 } 4547 4548 for key, value := range shape { 4549 switch key { 4550 case "CompletionTime": 4551 if value != nil { 4552 jtv, ok := value.(json.Number) 4553 if !ok { 4554 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 4555 } 4556 f64, err := jtv.Float64() 4557 if err != nil { 4558 return err 4559 } 4560 sv.CompletionTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4561 } 4562 4563 case "ContentRedaction": 4564 if err := awsAwsjson11_deserializeDocumentContentRedaction(&sv.ContentRedaction, value); err != nil { 4565 return err 4566 } 4567 4568 case "CreationTime": 4569 if value != nil { 4570 jtv, ok := value.(json.Number) 4571 if !ok { 4572 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 4573 } 4574 f64, err := jtv.Float64() 4575 if err != nil { 4576 return err 4577 } 4578 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4579 } 4580 4581 case "FailureReason": 4582 if value != nil { 4583 jtv, ok := value.(string) 4584 if !ok { 4585 return fmt.Errorf("expected FailureReason to be of type string, got %T instead", value) 4586 } 4587 sv.FailureReason = ptr.String(jtv) 4588 } 4589 4590 case "IdentifiedLanguageScore": 4591 if value != nil { 4592 jtv, ok := value.(json.Number) 4593 if !ok { 4594 return fmt.Errorf("expected IdentifiedLanguageScore to be json.Number, got %T instead", value) 4595 } 4596 f64, err := jtv.Float64() 4597 if err != nil { 4598 return err 4599 } 4600 sv.IdentifiedLanguageScore = ptr.Float32(float32(f64)) 4601 } 4602 4603 case "IdentifyLanguage": 4604 if value != nil { 4605 jtv, ok := value.(bool) 4606 if !ok { 4607 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 4608 } 4609 sv.IdentifyLanguage = ptr.Bool(jtv) 4610 } 4611 4612 case "JobExecutionSettings": 4613 if err := awsAwsjson11_deserializeDocumentJobExecutionSettings(&sv.JobExecutionSettings, value); err != nil { 4614 return err 4615 } 4616 4617 case "LanguageCode": 4618 if value != nil { 4619 jtv, ok := value.(string) 4620 if !ok { 4621 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 4622 } 4623 sv.LanguageCode = types.LanguageCode(jtv) 4624 } 4625 4626 case "LanguageOptions": 4627 if err := awsAwsjson11_deserializeDocumentLanguageOptions(&sv.LanguageOptions, value); err != nil { 4628 return err 4629 } 4630 4631 case "Media": 4632 if err := awsAwsjson11_deserializeDocumentMedia(&sv.Media, value); err != nil { 4633 return err 4634 } 4635 4636 case "MediaFormat": 4637 if value != nil { 4638 jtv, ok := value.(string) 4639 if !ok { 4640 return fmt.Errorf("expected MediaFormat to be of type string, got %T instead", value) 4641 } 4642 sv.MediaFormat = types.MediaFormat(jtv) 4643 } 4644 4645 case "MediaSampleRateHertz": 4646 if value != nil { 4647 jtv, ok := value.(json.Number) 4648 if !ok { 4649 return fmt.Errorf("expected MediaSampleRateHertz to be json.Number, got %T instead", value) 4650 } 4651 i64, err := jtv.Int64() 4652 if err != nil { 4653 return err 4654 } 4655 sv.MediaSampleRateHertz = ptr.Int32(int32(i64)) 4656 } 4657 4658 case "ModelSettings": 4659 if err := awsAwsjson11_deserializeDocumentModelSettings(&sv.ModelSettings, value); err != nil { 4660 return err 4661 } 4662 4663 case "Settings": 4664 if err := awsAwsjson11_deserializeDocumentSettings(&sv.Settings, value); err != nil { 4665 return err 4666 } 4667 4668 case "StartTime": 4669 if value != nil { 4670 jtv, ok := value.(json.Number) 4671 if !ok { 4672 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 4673 } 4674 f64, err := jtv.Float64() 4675 if err != nil { 4676 return err 4677 } 4678 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4679 } 4680 4681 case "Transcript": 4682 if err := awsAwsjson11_deserializeDocumentTranscript(&sv.Transcript, value); err != nil { 4683 return err 4684 } 4685 4686 case "TranscriptionJobName": 4687 if value != nil { 4688 jtv, ok := value.(string) 4689 if !ok { 4690 return fmt.Errorf("expected TranscriptionJobName to be of type string, got %T instead", value) 4691 } 4692 sv.TranscriptionJobName = ptr.String(jtv) 4693 } 4694 4695 case "TranscriptionJobStatus": 4696 if value != nil { 4697 jtv, ok := value.(string) 4698 if !ok { 4699 return fmt.Errorf("expected TranscriptionJobStatus to be of type string, got %T instead", value) 4700 } 4701 sv.TranscriptionJobStatus = types.TranscriptionJobStatus(jtv) 4702 } 4703 4704 default: 4705 _, _ = key, value 4706 4707 } 4708 } 4709 *v = sv 4710 return nil 4711} 4712 4713func awsAwsjson11_deserializeDocumentTranscriptionJobSummaries(v *[]types.TranscriptionJobSummary, value interface{}) error { 4714 if v == nil { 4715 return fmt.Errorf("unexpected nil of type %T", v) 4716 } 4717 if value == nil { 4718 return nil 4719 } 4720 4721 shape, ok := value.([]interface{}) 4722 if !ok { 4723 return fmt.Errorf("unexpected JSON type %v", value) 4724 } 4725 4726 var cv []types.TranscriptionJobSummary 4727 if *v == nil { 4728 cv = []types.TranscriptionJobSummary{} 4729 } else { 4730 cv = *v 4731 } 4732 4733 for _, value := range shape { 4734 var col types.TranscriptionJobSummary 4735 destAddr := &col 4736 if err := awsAwsjson11_deserializeDocumentTranscriptionJobSummary(&destAddr, value); err != nil { 4737 return err 4738 } 4739 col = *destAddr 4740 cv = append(cv, col) 4741 4742 } 4743 *v = cv 4744 return nil 4745} 4746 4747func awsAwsjson11_deserializeDocumentTranscriptionJobSummary(v **types.TranscriptionJobSummary, value interface{}) error { 4748 if v == nil { 4749 return fmt.Errorf("unexpected nil of type %T", v) 4750 } 4751 if value == nil { 4752 return nil 4753 } 4754 4755 shape, ok := value.(map[string]interface{}) 4756 if !ok { 4757 return fmt.Errorf("unexpected JSON type %v", value) 4758 } 4759 4760 var sv *types.TranscriptionJobSummary 4761 if *v == nil { 4762 sv = &types.TranscriptionJobSummary{} 4763 } else { 4764 sv = *v 4765 } 4766 4767 for key, value := range shape { 4768 switch key { 4769 case "CompletionTime": 4770 if value != nil { 4771 jtv, ok := value.(json.Number) 4772 if !ok { 4773 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 4774 } 4775 f64, err := jtv.Float64() 4776 if err != nil { 4777 return err 4778 } 4779 sv.CompletionTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4780 } 4781 4782 case "ContentRedaction": 4783 if err := awsAwsjson11_deserializeDocumentContentRedaction(&sv.ContentRedaction, value); err != nil { 4784 return err 4785 } 4786 4787 case "CreationTime": 4788 if value != nil { 4789 jtv, ok := value.(json.Number) 4790 if !ok { 4791 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 4792 } 4793 f64, err := jtv.Float64() 4794 if err != nil { 4795 return err 4796 } 4797 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4798 } 4799 4800 case "FailureReason": 4801 if value != nil { 4802 jtv, ok := value.(string) 4803 if !ok { 4804 return fmt.Errorf("expected FailureReason to be of type string, got %T instead", value) 4805 } 4806 sv.FailureReason = ptr.String(jtv) 4807 } 4808 4809 case "IdentifiedLanguageScore": 4810 if value != nil { 4811 jtv, ok := value.(json.Number) 4812 if !ok { 4813 return fmt.Errorf("expected IdentifiedLanguageScore to be json.Number, got %T instead", value) 4814 } 4815 f64, err := jtv.Float64() 4816 if err != nil { 4817 return err 4818 } 4819 sv.IdentifiedLanguageScore = ptr.Float32(float32(f64)) 4820 } 4821 4822 case "IdentifyLanguage": 4823 if value != nil { 4824 jtv, ok := value.(bool) 4825 if !ok { 4826 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 4827 } 4828 sv.IdentifyLanguage = ptr.Bool(jtv) 4829 } 4830 4831 case "LanguageCode": 4832 if value != nil { 4833 jtv, ok := value.(string) 4834 if !ok { 4835 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 4836 } 4837 sv.LanguageCode = types.LanguageCode(jtv) 4838 } 4839 4840 case "ModelSettings": 4841 if err := awsAwsjson11_deserializeDocumentModelSettings(&sv.ModelSettings, value); err != nil { 4842 return err 4843 } 4844 4845 case "OutputLocationType": 4846 if value != nil { 4847 jtv, ok := value.(string) 4848 if !ok { 4849 return fmt.Errorf("expected OutputLocationType to be of type string, got %T instead", value) 4850 } 4851 sv.OutputLocationType = types.OutputLocationType(jtv) 4852 } 4853 4854 case "StartTime": 4855 if value != nil { 4856 jtv, ok := value.(json.Number) 4857 if !ok { 4858 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 4859 } 4860 f64, err := jtv.Float64() 4861 if err != nil { 4862 return err 4863 } 4864 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4865 } 4866 4867 case "TranscriptionJobName": 4868 if value != nil { 4869 jtv, ok := value.(string) 4870 if !ok { 4871 return fmt.Errorf("expected TranscriptionJobName to be of type string, got %T instead", value) 4872 } 4873 sv.TranscriptionJobName = ptr.String(jtv) 4874 } 4875 4876 case "TranscriptionJobStatus": 4877 if value != nil { 4878 jtv, ok := value.(string) 4879 if !ok { 4880 return fmt.Errorf("expected TranscriptionJobStatus to be of type string, got %T instead", value) 4881 } 4882 sv.TranscriptionJobStatus = types.TranscriptionJobStatus(jtv) 4883 } 4884 4885 default: 4886 _, _ = key, value 4887 4888 } 4889 } 4890 *v = sv 4891 return nil 4892} 4893 4894func awsAwsjson11_deserializeDocumentVocabularies(v *[]types.VocabularyInfo, value interface{}) error { 4895 if v == nil { 4896 return fmt.Errorf("unexpected nil of type %T", v) 4897 } 4898 if value == nil { 4899 return nil 4900 } 4901 4902 shape, ok := value.([]interface{}) 4903 if !ok { 4904 return fmt.Errorf("unexpected JSON type %v", value) 4905 } 4906 4907 var cv []types.VocabularyInfo 4908 if *v == nil { 4909 cv = []types.VocabularyInfo{} 4910 } else { 4911 cv = *v 4912 } 4913 4914 for _, value := range shape { 4915 var col types.VocabularyInfo 4916 destAddr := &col 4917 if err := awsAwsjson11_deserializeDocumentVocabularyInfo(&destAddr, value); err != nil { 4918 return err 4919 } 4920 col = *destAddr 4921 cv = append(cv, col) 4922 4923 } 4924 *v = cv 4925 return nil 4926} 4927 4928func awsAwsjson11_deserializeDocumentVocabularyFilterInfo(v **types.VocabularyFilterInfo, value interface{}) error { 4929 if v == nil { 4930 return fmt.Errorf("unexpected nil of type %T", v) 4931 } 4932 if value == nil { 4933 return nil 4934 } 4935 4936 shape, ok := value.(map[string]interface{}) 4937 if !ok { 4938 return fmt.Errorf("unexpected JSON type %v", value) 4939 } 4940 4941 var sv *types.VocabularyFilterInfo 4942 if *v == nil { 4943 sv = &types.VocabularyFilterInfo{} 4944 } else { 4945 sv = *v 4946 } 4947 4948 for key, value := range shape { 4949 switch key { 4950 case "LanguageCode": 4951 if value != nil { 4952 jtv, ok := value.(string) 4953 if !ok { 4954 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 4955 } 4956 sv.LanguageCode = types.LanguageCode(jtv) 4957 } 4958 4959 case "LastModifiedTime": 4960 if value != nil { 4961 jtv, ok := value.(json.Number) 4962 if !ok { 4963 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 4964 } 4965 f64, err := jtv.Float64() 4966 if err != nil { 4967 return err 4968 } 4969 sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4970 } 4971 4972 case "VocabularyFilterName": 4973 if value != nil { 4974 jtv, ok := value.(string) 4975 if !ok { 4976 return fmt.Errorf("expected VocabularyFilterName to be of type string, got %T instead", value) 4977 } 4978 sv.VocabularyFilterName = ptr.String(jtv) 4979 } 4980 4981 default: 4982 _, _ = key, value 4983 4984 } 4985 } 4986 *v = sv 4987 return nil 4988} 4989 4990func awsAwsjson11_deserializeDocumentVocabularyFilters(v *[]types.VocabularyFilterInfo, value interface{}) error { 4991 if v == nil { 4992 return fmt.Errorf("unexpected nil of type %T", v) 4993 } 4994 if value == nil { 4995 return nil 4996 } 4997 4998 shape, ok := value.([]interface{}) 4999 if !ok { 5000 return fmt.Errorf("unexpected JSON type %v", value) 5001 } 5002 5003 var cv []types.VocabularyFilterInfo 5004 if *v == nil { 5005 cv = []types.VocabularyFilterInfo{} 5006 } else { 5007 cv = *v 5008 } 5009 5010 for _, value := range shape { 5011 var col types.VocabularyFilterInfo 5012 destAddr := &col 5013 if err := awsAwsjson11_deserializeDocumentVocabularyFilterInfo(&destAddr, value); err != nil { 5014 return err 5015 } 5016 col = *destAddr 5017 cv = append(cv, col) 5018 5019 } 5020 *v = cv 5021 return nil 5022} 5023 5024func awsAwsjson11_deserializeDocumentVocabularyInfo(v **types.VocabularyInfo, value interface{}) error { 5025 if v == nil { 5026 return fmt.Errorf("unexpected nil of type %T", v) 5027 } 5028 if value == nil { 5029 return nil 5030 } 5031 5032 shape, ok := value.(map[string]interface{}) 5033 if !ok { 5034 return fmt.Errorf("unexpected JSON type %v", value) 5035 } 5036 5037 var sv *types.VocabularyInfo 5038 if *v == nil { 5039 sv = &types.VocabularyInfo{} 5040 } else { 5041 sv = *v 5042 } 5043 5044 for key, value := range shape { 5045 switch key { 5046 case "LanguageCode": 5047 if value != nil { 5048 jtv, ok := value.(string) 5049 if !ok { 5050 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 5051 } 5052 sv.LanguageCode = types.LanguageCode(jtv) 5053 } 5054 5055 case "LastModifiedTime": 5056 if value != nil { 5057 jtv, ok := value.(json.Number) 5058 if !ok { 5059 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 5060 } 5061 f64, err := jtv.Float64() 5062 if err != nil { 5063 return err 5064 } 5065 sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5066 } 5067 5068 case "VocabularyName": 5069 if value != nil { 5070 jtv, ok := value.(string) 5071 if !ok { 5072 return fmt.Errorf("expected VocabularyName to be of type string, got %T instead", value) 5073 } 5074 sv.VocabularyName = ptr.String(jtv) 5075 } 5076 5077 case "VocabularyState": 5078 if value != nil { 5079 jtv, ok := value.(string) 5080 if !ok { 5081 return fmt.Errorf("expected VocabularyState to be of type string, got %T instead", value) 5082 } 5083 sv.VocabularyState = types.VocabularyState(jtv) 5084 } 5085 5086 default: 5087 _, _ = key, value 5088 5089 } 5090 } 5091 *v = sv 5092 return nil 5093} 5094 5095func awsAwsjson11_deserializeOpDocumentCreateLanguageModelOutput(v **CreateLanguageModelOutput, value interface{}) error { 5096 if v == nil { 5097 return fmt.Errorf("unexpected nil of type %T", v) 5098 } 5099 if value == nil { 5100 return nil 5101 } 5102 5103 shape, ok := value.(map[string]interface{}) 5104 if !ok { 5105 return fmt.Errorf("unexpected JSON type %v", value) 5106 } 5107 5108 var sv *CreateLanguageModelOutput 5109 if *v == nil { 5110 sv = &CreateLanguageModelOutput{} 5111 } else { 5112 sv = *v 5113 } 5114 5115 for key, value := range shape { 5116 switch key { 5117 case "BaseModelName": 5118 if value != nil { 5119 jtv, ok := value.(string) 5120 if !ok { 5121 return fmt.Errorf("expected BaseModelName to be of type string, got %T instead", value) 5122 } 5123 sv.BaseModelName = types.BaseModelName(jtv) 5124 } 5125 5126 case "InputDataConfig": 5127 if err := awsAwsjson11_deserializeDocumentInputDataConfig(&sv.InputDataConfig, value); err != nil { 5128 return err 5129 } 5130 5131 case "LanguageCode": 5132 if value != nil { 5133 jtv, ok := value.(string) 5134 if !ok { 5135 return fmt.Errorf("expected CLMLanguageCode to be of type string, got %T instead", value) 5136 } 5137 sv.LanguageCode = types.CLMLanguageCode(jtv) 5138 } 5139 5140 case "ModelName": 5141 if value != nil { 5142 jtv, ok := value.(string) 5143 if !ok { 5144 return fmt.Errorf("expected ModelName to be of type string, got %T instead", value) 5145 } 5146 sv.ModelName = ptr.String(jtv) 5147 } 5148 5149 case "ModelStatus": 5150 if value != nil { 5151 jtv, ok := value.(string) 5152 if !ok { 5153 return fmt.Errorf("expected ModelStatus to be of type string, got %T instead", value) 5154 } 5155 sv.ModelStatus = types.ModelStatus(jtv) 5156 } 5157 5158 default: 5159 _, _ = key, value 5160 5161 } 5162 } 5163 *v = sv 5164 return nil 5165} 5166 5167func awsAwsjson11_deserializeOpDocumentCreateMedicalVocabularyOutput(v **CreateMedicalVocabularyOutput, value interface{}) error { 5168 if v == nil { 5169 return fmt.Errorf("unexpected nil of type %T", v) 5170 } 5171 if value == nil { 5172 return nil 5173 } 5174 5175 shape, ok := value.(map[string]interface{}) 5176 if !ok { 5177 return fmt.Errorf("unexpected JSON type %v", value) 5178 } 5179 5180 var sv *CreateMedicalVocabularyOutput 5181 if *v == nil { 5182 sv = &CreateMedicalVocabularyOutput{} 5183 } else { 5184 sv = *v 5185 } 5186 5187 for key, value := range shape { 5188 switch key { 5189 case "FailureReason": 5190 if value != nil { 5191 jtv, ok := value.(string) 5192 if !ok { 5193 return fmt.Errorf("expected FailureReason to be of type string, got %T instead", value) 5194 } 5195 sv.FailureReason = ptr.String(jtv) 5196 } 5197 5198 case "LanguageCode": 5199 if value != nil { 5200 jtv, ok := value.(string) 5201 if !ok { 5202 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 5203 } 5204 sv.LanguageCode = types.LanguageCode(jtv) 5205 } 5206 5207 case "LastModifiedTime": 5208 if value != nil { 5209 jtv, ok := value.(json.Number) 5210 if !ok { 5211 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 5212 } 5213 f64, err := jtv.Float64() 5214 if err != nil { 5215 return err 5216 } 5217 sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5218 } 5219 5220 case "VocabularyName": 5221 if value != nil { 5222 jtv, ok := value.(string) 5223 if !ok { 5224 return fmt.Errorf("expected VocabularyName to be of type string, got %T instead", value) 5225 } 5226 sv.VocabularyName = ptr.String(jtv) 5227 } 5228 5229 case "VocabularyState": 5230 if value != nil { 5231 jtv, ok := value.(string) 5232 if !ok { 5233 return fmt.Errorf("expected VocabularyState to be of type string, got %T instead", value) 5234 } 5235 sv.VocabularyState = types.VocabularyState(jtv) 5236 } 5237 5238 default: 5239 _, _ = key, value 5240 5241 } 5242 } 5243 *v = sv 5244 return nil 5245} 5246 5247func awsAwsjson11_deserializeOpDocumentCreateVocabularyFilterOutput(v **CreateVocabularyFilterOutput, value interface{}) error { 5248 if v == nil { 5249 return fmt.Errorf("unexpected nil of type %T", v) 5250 } 5251 if value == nil { 5252 return nil 5253 } 5254 5255 shape, ok := value.(map[string]interface{}) 5256 if !ok { 5257 return fmt.Errorf("unexpected JSON type %v", value) 5258 } 5259 5260 var sv *CreateVocabularyFilterOutput 5261 if *v == nil { 5262 sv = &CreateVocabularyFilterOutput{} 5263 } else { 5264 sv = *v 5265 } 5266 5267 for key, value := range shape { 5268 switch key { 5269 case "LanguageCode": 5270 if value != nil { 5271 jtv, ok := value.(string) 5272 if !ok { 5273 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 5274 } 5275 sv.LanguageCode = types.LanguageCode(jtv) 5276 } 5277 5278 case "LastModifiedTime": 5279 if value != nil { 5280 jtv, ok := value.(json.Number) 5281 if !ok { 5282 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 5283 } 5284 f64, err := jtv.Float64() 5285 if err != nil { 5286 return err 5287 } 5288 sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5289 } 5290 5291 case "VocabularyFilterName": 5292 if value != nil { 5293 jtv, ok := value.(string) 5294 if !ok { 5295 return fmt.Errorf("expected VocabularyFilterName to be of type string, got %T instead", value) 5296 } 5297 sv.VocabularyFilterName = ptr.String(jtv) 5298 } 5299 5300 default: 5301 _, _ = key, value 5302 5303 } 5304 } 5305 *v = sv 5306 return nil 5307} 5308 5309func awsAwsjson11_deserializeOpDocumentCreateVocabularyOutput(v **CreateVocabularyOutput, value interface{}) error { 5310 if v == nil { 5311 return fmt.Errorf("unexpected nil of type %T", v) 5312 } 5313 if value == nil { 5314 return nil 5315 } 5316 5317 shape, ok := value.(map[string]interface{}) 5318 if !ok { 5319 return fmt.Errorf("unexpected JSON type %v", value) 5320 } 5321 5322 var sv *CreateVocabularyOutput 5323 if *v == nil { 5324 sv = &CreateVocabularyOutput{} 5325 } else { 5326 sv = *v 5327 } 5328 5329 for key, value := range shape { 5330 switch key { 5331 case "FailureReason": 5332 if value != nil { 5333 jtv, ok := value.(string) 5334 if !ok { 5335 return fmt.Errorf("expected FailureReason to be of type string, got %T instead", value) 5336 } 5337 sv.FailureReason = ptr.String(jtv) 5338 } 5339 5340 case "LanguageCode": 5341 if value != nil { 5342 jtv, ok := value.(string) 5343 if !ok { 5344 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 5345 } 5346 sv.LanguageCode = types.LanguageCode(jtv) 5347 } 5348 5349 case "LastModifiedTime": 5350 if value != nil { 5351 jtv, ok := value.(json.Number) 5352 if !ok { 5353 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 5354 } 5355 f64, err := jtv.Float64() 5356 if err != nil { 5357 return err 5358 } 5359 sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5360 } 5361 5362 case "VocabularyName": 5363 if value != nil { 5364 jtv, ok := value.(string) 5365 if !ok { 5366 return fmt.Errorf("expected VocabularyName to be of type string, got %T instead", value) 5367 } 5368 sv.VocabularyName = ptr.String(jtv) 5369 } 5370 5371 case "VocabularyState": 5372 if value != nil { 5373 jtv, ok := value.(string) 5374 if !ok { 5375 return fmt.Errorf("expected VocabularyState to be of type string, got %T instead", value) 5376 } 5377 sv.VocabularyState = types.VocabularyState(jtv) 5378 } 5379 5380 default: 5381 _, _ = key, value 5382 5383 } 5384 } 5385 *v = sv 5386 return nil 5387} 5388 5389func awsAwsjson11_deserializeOpDocumentDescribeLanguageModelOutput(v **DescribeLanguageModelOutput, value interface{}) error { 5390 if v == nil { 5391 return fmt.Errorf("unexpected nil of type %T", v) 5392 } 5393 if value == nil { 5394 return nil 5395 } 5396 5397 shape, ok := value.(map[string]interface{}) 5398 if !ok { 5399 return fmt.Errorf("unexpected JSON type %v", value) 5400 } 5401 5402 var sv *DescribeLanguageModelOutput 5403 if *v == nil { 5404 sv = &DescribeLanguageModelOutput{} 5405 } else { 5406 sv = *v 5407 } 5408 5409 for key, value := range shape { 5410 switch key { 5411 case "LanguageModel": 5412 if err := awsAwsjson11_deserializeDocumentLanguageModel(&sv.LanguageModel, value); err != nil { 5413 return err 5414 } 5415 5416 default: 5417 _, _ = key, value 5418 5419 } 5420 } 5421 *v = sv 5422 return nil 5423} 5424 5425func awsAwsjson11_deserializeOpDocumentGetMedicalTranscriptionJobOutput(v **GetMedicalTranscriptionJobOutput, value interface{}) error { 5426 if v == nil { 5427 return fmt.Errorf("unexpected nil of type %T", v) 5428 } 5429 if value == nil { 5430 return nil 5431 } 5432 5433 shape, ok := value.(map[string]interface{}) 5434 if !ok { 5435 return fmt.Errorf("unexpected JSON type %v", value) 5436 } 5437 5438 var sv *GetMedicalTranscriptionJobOutput 5439 if *v == nil { 5440 sv = &GetMedicalTranscriptionJobOutput{} 5441 } else { 5442 sv = *v 5443 } 5444 5445 for key, value := range shape { 5446 switch key { 5447 case "MedicalTranscriptionJob": 5448 if err := awsAwsjson11_deserializeDocumentMedicalTranscriptionJob(&sv.MedicalTranscriptionJob, value); err != nil { 5449 return err 5450 } 5451 5452 default: 5453 _, _ = key, value 5454 5455 } 5456 } 5457 *v = sv 5458 return nil 5459} 5460 5461func awsAwsjson11_deserializeOpDocumentGetMedicalVocabularyOutput(v **GetMedicalVocabularyOutput, value interface{}) error { 5462 if v == nil { 5463 return fmt.Errorf("unexpected nil of type %T", v) 5464 } 5465 if value == nil { 5466 return nil 5467 } 5468 5469 shape, ok := value.(map[string]interface{}) 5470 if !ok { 5471 return fmt.Errorf("unexpected JSON type %v", value) 5472 } 5473 5474 var sv *GetMedicalVocabularyOutput 5475 if *v == nil { 5476 sv = &GetMedicalVocabularyOutput{} 5477 } else { 5478 sv = *v 5479 } 5480 5481 for key, value := range shape { 5482 switch key { 5483 case "DownloadUri": 5484 if value != nil { 5485 jtv, ok := value.(string) 5486 if !ok { 5487 return fmt.Errorf("expected Uri to be of type string, got %T instead", value) 5488 } 5489 sv.DownloadUri = ptr.String(jtv) 5490 } 5491 5492 case "FailureReason": 5493 if value != nil { 5494 jtv, ok := value.(string) 5495 if !ok { 5496 return fmt.Errorf("expected FailureReason to be of type string, got %T instead", value) 5497 } 5498 sv.FailureReason = ptr.String(jtv) 5499 } 5500 5501 case "LanguageCode": 5502 if value != nil { 5503 jtv, ok := value.(string) 5504 if !ok { 5505 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 5506 } 5507 sv.LanguageCode = types.LanguageCode(jtv) 5508 } 5509 5510 case "LastModifiedTime": 5511 if value != nil { 5512 jtv, ok := value.(json.Number) 5513 if !ok { 5514 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 5515 } 5516 f64, err := jtv.Float64() 5517 if err != nil { 5518 return err 5519 } 5520 sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5521 } 5522 5523 case "VocabularyName": 5524 if value != nil { 5525 jtv, ok := value.(string) 5526 if !ok { 5527 return fmt.Errorf("expected VocabularyName to be of type string, got %T instead", value) 5528 } 5529 sv.VocabularyName = ptr.String(jtv) 5530 } 5531 5532 case "VocabularyState": 5533 if value != nil { 5534 jtv, ok := value.(string) 5535 if !ok { 5536 return fmt.Errorf("expected VocabularyState to be of type string, got %T instead", value) 5537 } 5538 sv.VocabularyState = types.VocabularyState(jtv) 5539 } 5540 5541 default: 5542 _, _ = key, value 5543 5544 } 5545 } 5546 *v = sv 5547 return nil 5548} 5549 5550func awsAwsjson11_deserializeOpDocumentGetTranscriptionJobOutput(v **GetTranscriptionJobOutput, value interface{}) error { 5551 if v == nil { 5552 return fmt.Errorf("unexpected nil of type %T", v) 5553 } 5554 if value == nil { 5555 return nil 5556 } 5557 5558 shape, ok := value.(map[string]interface{}) 5559 if !ok { 5560 return fmt.Errorf("unexpected JSON type %v", value) 5561 } 5562 5563 var sv *GetTranscriptionJobOutput 5564 if *v == nil { 5565 sv = &GetTranscriptionJobOutput{} 5566 } else { 5567 sv = *v 5568 } 5569 5570 for key, value := range shape { 5571 switch key { 5572 case "TranscriptionJob": 5573 if err := awsAwsjson11_deserializeDocumentTranscriptionJob(&sv.TranscriptionJob, value); err != nil { 5574 return err 5575 } 5576 5577 default: 5578 _, _ = key, value 5579 5580 } 5581 } 5582 *v = sv 5583 return nil 5584} 5585 5586func awsAwsjson11_deserializeOpDocumentGetVocabularyFilterOutput(v **GetVocabularyFilterOutput, value interface{}) error { 5587 if v == nil { 5588 return fmt.Errorf("unexpected nil of type %T", v) 5589 } 5590 if value == nil { 5591 return nil 5592 } 5593 5594 shape, ok := value.(map[string]interface{}) 5595 if !ok { 5596 return fmt.Errorf("unexpected JSON type %v", value) 5597 } 5598 5599 var sv *GetVocabularyFilterOutput 5600 if *v == nil { 5601 sv = &GetVocabularyFilterOutput{} 5602 } else { 5603 sv = *v 5604 } 5605 5606 for key, value := range shape { 5607 switch key { 5608 case "DownloadUri": 5609 if value != nil { 5610 jtv, ok := value.(string) 5611 if !ok { 5612 return fmt.Errorf("expected Uri to be of type string, got %T instead", value) 5613 } 5614 sv.DownloadUri = ptr.String(jtv) 5615 } 5616 5617 case "LanguageCode": 5618 if value != nil { 5619 jtv, ok := value.(string) 5620 if !ok { 5621 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 5622 } 5623 sv.LanguageCode = types.LanguageCode(jtv) 5624 } 5625 5626 case "LastModifiedTime": 5627 if value != nil { 5628 jtv, ok := value.(json.Number) 5629 if !ok { 5630 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 5631 } 5632 f64, err := jtv.Float64() 5633 if err != nil { 5634 return err 5635 } 5636 sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5637 } 5638 5639 case "VocabularyFilterName": 5640 if value != nil { 5641 jtv, ok := value.(string) 5642 if !ok { 5643 return fmt.Errorf("expected VocabularyFilterName to be of type string, got %T instead", value) 5644 } 5645 sv.VocabularyFilterName = ptr.String(jtv) 5646 } 5647 5648 default: 5649 _, _ = key, value 5650 5651 } 5652 } 5653 *v = sv 5654 return nil 5655} 5656 5657func awsAwsjson11_deserializeOpDocumentGetVocabularyOutput(v **GetVocabularyOutput, value interface{}) error { 5658 if v == nil { 5659 return fmt.Errorf("unexpected nil of type %T", v) 5660 } 5661 if value == nil { 5662 return nil 5663 } 5664 5665 shape, ok := value.(map[string]interface{}) 5666 if !ok { 5667 return fmt.Errorf("unexpected JSON type %v", value) 5668 } 5669 5670 var sv *GetVocabularyOutput 5671 if *v == nil { 5672 sv = &GetVocabularyOutput{} 5673 } else { 5674 sv = *v 5675 } 5676 5677 for key, value := range shape { 5678 switch key { 5679 case "DownloadUri": 5680 if value != nil { 5681 jtv, ok := value.(string) 5682 if !ok { 5683 return fmt.Errorf("expected Uri to be of type string, got %T instead", value) 5684 } 5685 sv.DownloadUri = ptr.String(jtv) 5686 } 5687 5688 case "FailureReason": 5689 if value != nil { 5690 jtv, ok := value.(string) 5691 if !ok { 5692 return fmt.Errorf("expected FailureReason to be of type string, got %T instead", value) 5693 } 5694 sv.FailureReason = ptr.String(jtv) 5695 } 5696 5697 case "LanguageCode": 5698 if value != nil { 5699 jtv, ok := value.(string) 5700 if !ok { 5701 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 5702 } 5703 sv.LanguageCode = types.LanguageCode(jtv) 5704 } 5705 5706 case "LastModifiedTime": 5707 if value != nil { 5708 jtv, ok := value.(json.Number) 5709 if !ok { 5710 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 5711 } 5712 f64, err := jtv.Float64() 5713 if err != nil { 5714 return err 5715 } 5716 sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5717 } 5718 5719 case "VocabularyName": 5720 if value != nil { 5721 jtv, ok := value.(string) 5722 if !ok { 5723 return fmt.Errorf("expected VocabularyName to be of type string, got %T instead", value) 5724 } 5725 sv.VocabularyName = ptr.String(jtv) 5726 } 5727 5728 case "VocabularyState": 5729 if value != nil { 5730 jtv, ok := value.(string) 5731 if !ok { 5732 return fmt.Errorf("expected VocabularyState to be of type string, got %T instead", value) 5733 } 5734 sv.VocabularyState = types.VocabularyState(jtv) 5735 } 5736 5737 default: 5738 _, _ = key, value 5739 5740 } 5741 } 5742 *v = sv 5743 return nil 5744} 5745 5746func awsAwsjson11_deserializeOpDocumentListLanguageModelsOutput(v **ListLanguageModelsOutput, value interface{}) error { 5747 if v == nil { 5748 return fmt.Errorf("unexpected nil of type %T", v) 5749 } 5750 if value == nil { 5751 return nil 5752 } 5753 5754 shape, ok := value.(map[string]interface{}) 5755 if !ok { 5756 return fmt.Errorf("unexpected JSON type %v", value) 5757 } 5758 5759 var sv *ListLanguageModelsOutput 5760 if *v == nil { 5761 sv = &ListLanguageModelsOutput{} 5762 } else { 5763 sv = *v 5764 } 5765 5766 for key, value := range shape { 5767 switch key { 5768 case "Models": 5769 if err := awsAwsjson11_deserializeDocumentModels(&sv.Models, value); err != nil { 5770 return err 5771 } 5772 5773 case "NextToken": 5774 if value != nil { 5775 jtv, ok := value.(string) 5776 if !ok { 5777 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 5778 } 5779 sv.NextToken = ptr.String(jtv) 5780 } 5781 5782 default: 5783 _, _ = key, value 5784 5785 } 5786 } 5787 *v = sv 5788 return nil 5789} 5790 5791func awsAwsjson11_deserializeOpDocumentListMedicalTranscriptionJobsOutput(v **ListMedicalTranscriptionJobsOutput, value interface{}) error { 5792 if v == nil { 5793 return fmt.Errorf("unexpected nil of type %T", v) 5794 } 5795 if value == nil { 5796 return nil 5797 } 5798 5799 shape, ok := value.(map[string]interface{}) 5800 if !ok { 5801 return fmt.Errorf("unexpected JSON type %v", value) 5802 } 5803 5804 var sv *ListMedicalTranscriptionJobsOutput 5805 if *v == nil { 5806 sv = &ListMedicalTranscriptionJobsOutput{} 5807 } else { 5808 sv = *v 5809 } 5810 5811 for key, value := range shape { 5812 switch key { 5813 case "MedicalTranscriptionJobSummaries": 5814 if err := awsAwsjson11_deserializeDocumentMedicalTranscriptionJobSummaries(&sv.MedicalTranscriptionJobSummaries, value); err != nil { 5815 return err 5816 } 5817 5818 case "NextToken": 5819 if value != nil { 5820 jtv, ok := value.(string) 5821 if !ok { 5822 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 5823 } 5824 sv.NextToken = ptr.String(jtv) 5825 } 5826 5827 case "Status": 5828 if value != nil { 5829 jtv, ok := value.(string) 5830 if !ok { 5831 return fmt.Errorf("expected TranscriptionJobStatus to be of type string, got %T instead", value) 5832 } 5833 sv.Status = types.TranscriptionJobStatus(jtv) 5834 } 5835 5836 default: 5837 _, _ = key, value 5838 5839 } 5840 } 5841 *v = sv 5842 return nil 5843} 5844 5845func awsAwsjson11_deserializeOpDocumentListMedicalVocabulariesOutput(v **ListMedicalVocabulariesOutput, value interface{}) error { 5846 if v == nil { 5847 return fmt.Errorf("unexpected nil of type %T", v) 5848 } 5849 if value == nil { 5850 return nil 5851 } 5852 5853 shape, ok := value.(map[string]interface{}) 5854 if !ok { 5855 return fmt.Errorf("unexpected JSON type %v", value) 5856 } 5857 5858 var sv *ListMedicalVocabulariesOutput 5859 if *v == nil { 5860 sv = &ListMedicalVocabulariesOutput{} 5861 } else { 5862 sv = *v 5863 } 5864 5865 for key, value := range shape { 5866 switch key { 5867 case "NextToken": 5868 if value != nil { 5869 jtv, ok := value.(string) 5870 if !ok { 5871 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 5872 } 5873 sv.NextToken = ptr.String(jtv) 5874 } 5875 5876 case "Status": 5877 if value != nil { 5878 jtv, ok := value.(string) 5879 if !ok { 5880 return fmt.Errorf("expected VocabularyState to be of type string, got %T instead", value) 5881 } 5882 sv.Status = types.VocabularyState(jtv) 5883 } 5884 5885 case "Vocabularies": 5886 if err := awsAwsjson11_deserializeDocumentVocabularies(&sv.Vocabularies, value); err != nil { 5887 return err 5888 } 5889 5890 default: 5891 _, _ = key, value 5892 5893 } 5894 } 5895 *v = sv 5896 return nil 5897} 5898 5899func awsAwsjson11_deserializeOpDocumentListTranscriptionJobsOutput(v **ListTranscriptionJobsOutput, value interface{}) error { 5900 if v == nil { 5901 return fmt.Errorf("unexpected nil of type %T", v) 5902 } 5903 if value == nil { 5904 return nil 5905 } 5906 5907 shape, ok := value.(map[string]interface{}) 5908 if !ok { 5909 return fmt.Errorf("unexpected JSON type %v", value) 5910 } 5911 5912 var sv *ListTranscriptionJobsOutput 5913 if *v == nil { 5914 sv = &ListTranscriptionJobsOutput{} 5915 } else { 5916 sv = *v 5917 } 5918 5919 for key, value := range shape { 5920 switch key { 5921 case "NextToken": 5922 if value != nil { 5923 jtv, ok := value.(string) 5924 if !ok { 5925 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 5926 } 5927 sv.NextToken = ptr.String(jtv) 5928 } 5929 5930 case "Status": 5931 if value != nil { 5932 jtv, ok := value.(string) 5933 if !ok { 5934 return fmt.Errorf("expected TranscriptionJobStatus to be of type string, got %T instead", value) 5935 } 5936 sv.Status = types.TranscriptionJobStatus(jtv) 5937 } 5938 5939 case "TranscriptionJobSummaries": 5940 if err := awsAwsjson11_deserializeDocumentTranscriptionJobSummaries(&sv.TranscriptionJobSummaries, value); err != nil { 5941 return err 5942 } 5943 5944 default: 5945 _, _ = key, value 5946 5947 } 5948 } 5949 *v = sv 5950 return nil 5951} 5952 5953func awsAwsjson11_deserializeOpDocumentListVocabulariesOutput(v **ListVocabulariesOutput, value interface{}) error { 5954 if v == nil { 5955 return fmt.Errorf("unexpected nil of type %T", v) 5956 } 5957 if value == nil { 5958 return nil 5959 } 5960 5961 shape, ok := value.(map[string]interface{}) 5962 if !ok { 5963 return fmt.Errorf("unexpected JSON type %v", value) 5964 } 5965 5966 var sv *ListVocabulariesOutput 5967 if *v == nil { 5968 sv = &ListVocabulariesOutput{} 5969 } else { 5970 sv = *v 5971 } 5972 5973 for key, value := range shape { 5974 switch key { 5975 case "NextToken": 5976 if value != nil { 5977 jtv, ok := value.(string) 5978 if !ok { 5979 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 5980 } 5981 sv.NextToken = ptr.String(jtv) 5982 } 5983 5984 case "Status": 5985 if value != nil { 5986 jtv, ok := value.(string) 5987 if !ok { 5988 return fmt.Errorf("expected VocabularyState to be of type string, got %T instead", value) 5989 } 5990 sv.Status = types.VocabularyState(jtv) 5991 } 5992 5993 case "Vocabularies": 5994 if err := awsAwsjson11_deserializeDocumentVocabularies(&sv.Vocabularies, value); err != nil { 5995 return err 5996 } 5997 5998 default: 5999 _, _ = key, value 6000 6001 } 6002 } 6003 *v = sv 6004 return nil 6005} 6006 6007func awsAwsjson11_deserializeOpDocumentListVocabularyFiltersOutput(v **ListVocabularyFiltersOutput, value interface{}) error { 6008 if v == nil { 6009 return fmt.Errorf("unexpected nil of type %T", v) 6010 } 6011 if value == nil { 6012 return nil 6013 } 6014 6015 shape, ok := value.(map[string]interface{}) 6016 if !ok { 6017 return fmt.Errorf("unexpected JSON type %v", value) 6018 } 6019 6020 var sv *ListVocabularyFiltersOutput 6021 if *v == nil { 6022 sv = &ListVocabularyFiltersOutput{} 6023 } else { 6024 sv = *v 6025 } 6026 6027 for key, value := range shape { 6028 switch key { 6029 case "NextToken": 6030 if value != nil { 6031 jtv, ok := value.(string) 6032 if !ok { 6033 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 6034 } 6035 sv.NextToken = ptr.String(jtv) 6036 } 6037 6038 case "VocabularyFilters": 6039 if err := awsAwsjson11_deserializeDocumentVocabularyFilters(&sv.VocabularyFilters, value); err != nil { 6040 return err 6041 } 6042 6043 default: 6044 _, _ = key, value 6045 6046 } 6047 } 6048 *v = sv 6049 return nil 6050} 6051 6052func awsAwsjson11_deserializeOpDocumentStartMedicalTranscriptionJobOutput(v **StartMedicalTranscriptionJobOutput, value interface{}) error { 6053 if v == nil { 6054 return fmt.Errorf("unexpected nil of type %T", v) 6055 } 6056 if value == nil { 6057 return nil 6058 } 6059 6060 shape, ok := value.(map[string]interface{}) 6061 if !ok { 6062 return fmt.Errorf("unexpected JSON type %v", value) 6063 } 6064 6065 var sv *StartMedicalTranscriptionJobOutput 6066 if *v == nil { 6067 sv = &StartMedicalTranscriptionJobOutput{} 6068 } else { 6069 sv = *v 6070 } 6071 6072 for key, value := range shape { 6073 switch key { 6074 case "MedicalTranscriptionJob": 6075 if err := awsAwsjson11_deserializeDocumentMedicalTranscriptionJob(&sv.MedicalTranscriptionJob, value); err != nil { 6076 return err 6077 } 6078 6079 default: 6080 _, _ = key, value 6081 6082 } 6083 } 6084 *v = sv 6085 return nil 6086} 6087 6088func awsAwsjson11_deserializeOpDocumentStartTranscriptionJobOutput(v **StartTranscriptionJobOutput, value interface{}) error { 6089 if v == nil { 6090 return fmt.Errorf("unexpected nil of type %T", v) 6091 } 6092 if value == nil { 6093 return nil 6094 } 6095 6096 shape, ok := value.(map[string]interface{}) 6097 if !ok { 6098 return fmt.Errorf("unexpected JSON type %v", value) 6099 } 6100 6101 var sv *StartTranscriptionJobOutput 6102 if *v == nil { 6103 sv = &StartTranscriptionJobOutput{} 6104 } else { 6105 sv = *v 6106 } 6107 6108 for key, value := range shape { 6109 switch key { 6110 case "TranscriptionJob": 6111 if err := awsAwsjson11_deserializeDocumentTranscriptionJob(&sv.TranscriptionJob, value); err != nil { 6112 return err 6113 } 6114 6115 default: 6116 _, _ = key, value 6117 6118 } 6119 } 6120 *v = sv 6121 return nil 6122} 6123 6124func awsAwsjson11_deserializeOpDocumentUpdateMedicalVocabularyOutput(v **UpdateMedicalVocabularyOutput, value interface{}) error { 6125 if v == nil { 6126 return fmt.Errorf("unexpected nil of type %T", v) 6127 } 6128 if value == nil { 6129 return nil 6130 } 6131 6132 shape, ok := value.(map[string]interface{}) 6133 if !ok { 6134 return fmt.Errorf("unexpected JSON type %v", value) 6135 } 6136 6137 var sv *UpdateMedicalVocabularyOutput 6138 if *v == nil { 6139 sv = &UpdateMedicalVocabularyOutput{} 6140 } else { 6141 sv = *v 6142 } 6143 6144 for key, value := range shape { 6145 switch key { 6146 case "LanguageCode": 6147 if value != nil { 6148 jtv, ok := value.(string) 6149 if !ok { 6150 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 6151 } 6152 sv.LanguageCode = types.LanguageCode(jtv) 6153 } 6154 6155 case "LastModifiedTime": 6156 if value != nil { 6157 jtv, ok := value.(json.Number) 6158 if !ok { 6159 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 6160 } 6161 f64, err := jtv.Float64() 6162 if err != nil { 6163 return err 6164 } 6165 sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6166 } 6167 6168 case "VocabularyName": 6169 if value != nil { 6170 jtv, ok := value.(string) 6171 if !ok { 6172 return fmt.Errorf("expected VocabularyName to be of type string, got %T instead", value) 6173 } 6174 sv.VocabularyName = ptr.String(jtv) 6175 } 6176 6177 case "VocabularyState": 6178 if value != nil { 6179 jtv, ok := value.(string) 6180 if !ok { 6181 return fmt.Errorf("expected VocabularyState to be of type string, got %T instead", value) 6182 } 6183 sv.VocabularyState = types.VocabularyState(jtv) 6184 } 6185 6186 default: 6187 _, _ = key, value 6188 6189 } 6190 } 6191 *v = sv 6192 return nil 6193} 6194 6195func awsAwsjson11_deserializeOpDocumentUpdateVocabularyFilterOutput(v **UpdateVocabularyFilterOutput, value interface{}) error { 6196 if v == nil { 6197 return fmt.Errorf("unexpected nil of type %T", v) 6198 } 6199 if value == nil { 6200 return nil 6201 } 6202 6203 shape, ok := value.(map[string]interface{}) 6204 if !ok { 6205 return fmt.Errorf("unexpected JSON type %v", value) 6206 } 6207 6208 var sv *UpdateVocabularyFilterOutput 6209 if *v == nil { 6210 sv = &UpdateVocabularyFilterOutput{} 6211 } else { 6212 sv = *v 6213 } 6214 6215 for key, value := range shape { 6216 switch key { 6217 case "LanguageCode": 6218 if value != nil { 6219 jtv, ok := value.(string) 6220 if !ok { 6221 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 6222 } 6223 sv.LanguageCode = types.LanguageCode(jtv) 6224 } 6225 6226 case "LastModifiedTime": 6227 if value != nil { 6228 jtv, ok := value.(json.Number) 6229 if !ok { 6230 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 6231 } 6232 f64, err := jtv.Float64() 6233 if err != nil { 6234 return err 6235 } 6236 sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6237 } 6238 6239 case "VocabularyFilterName": 6240 if value != nil { 6241 jtv, ok := value.(string) 6242 if !ok { 6243 return fmt.Errorf("expected VocabularyFilterName to be of type string, got %T instead", value) 6244 } 6245 sv.VocabularyFilterName = ptr.String(jtv) 6246 } 6247 6248 default: 6249 _, _ = key, value 6250 6251 } 6252 } 6253 *v = sv 6254 return nil 6255} 6256 6257func awsAwsjson11_deserializeOpDocumentUpdateVocabularyOutput(v **UpdateVocabularyOutput, value interface{}) error { 6258 if v == nil { 6259 return fmt.Errorf("unexpected nil of type %T", v) 6260 } 6261 if value == nil { 6262 return nil 6263 } 6264 6265 shape, ok := value.(map[string]interface{}) 6266 if !ok { 6267 return fmt.Errorf("unexpected JSON type %v", value) 6268 } 6269 6270 var sv *UpdateVocabularyOutput 6271 if *v == nil { 6272 sv = &UpdateVocabularyOutput{} 6273 } else { 6274 sv = *v 6275 } 6276 6277 for key, value := range shape { 6278 switch key { 6279 case "LanguageCode": 6280 if value != nil { 6281 jtv, ok := value.(string) 6282 if !ok { 6283 return fmt.Errorf("expected LanguageCode to be of type string, got %T instead", value) 6284 } 6285 sv.LanguageCode = types.LanguageCode(jtv) 6286 } 6287 6288 case "LastModifiedTime": 6289 if value != nil { 6290 jtv, ok := value.(json.Number) 6291 if !ok { 6292 return fmt.Errorf("expected DateTime to be json.Number, got %T instead", value) 6293 } 6294 f64, err := jtv.Float64() 6295 if err != nil { 6296 return err 6297 } 6298 sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6299 } 6300 6301 case "VocabularyName": 6302 if value != nil { 6303 jtv, ok := value.(string) 6304 if !ok { 6305 return fmt.Errorf("expected VocabularyName to be of type string, got %T instead", value) 6306 } 6307 sv.VocabularyName = ptr.String(jtv) 6308 } 6309 6310 case "VocabularyState": 6311 if value != nil { 6312 jtv, ok := value.(string) 6313 if !ok { 6314 return fmt.Errorf("expected VocabularyState to be of type string, got %T instead", value) 6315 } 6316 sv.VocabularyState = types.VocabularyState(jtv) 6317 } 6318 6319 default: 6320 _, _ = key, value 6321 6322 } 6323 } 6324 *v = sv 6325 return nil 6326} 6327