@aws-sdk/client-machine-learning 3.52.0 → 3.53.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (16) hide show
  1. package/CHANGELOG.md +11 -0
  2. package/dist-cjs/index.js +3 -0
  3. package/dist-cjs/models/MachineLearningServiceException.js +11 -0
  4. package/dist-cjs/models/models_0.js +112 -2
  5. package/dist-cjs/protocols/Aws_json1_1.js +233 -835
  6. package/dist-es/index.js +1 -0
  7. package/dist-es/models/MachineLearningServiceException.js +12 -0
  8. package/dist-es/models/models_0.js +103 -1
  9. package/dist-es/protocols/Aws_json1_1.js +543 -932
  10. package/dist-types/index.d.ts +1 -0
  11. package/dist-types/models/MachineLearningServiceException.d.ts +10 -0
  12. package/dist-types/models/models_0.d.ts +58 -33
  13. package/dist-types/ts3.4/index.d.ts +1 -0
  14. package/dist-types/ts3.4/models/MachineLearningServiceException.d.ts +6 -0
  15. package/dist-types/ts3.4/models/models_0.d.ts +42 -33
  16. package/package.json +27 -27
package/dist-cjs/protocols/Aws_json1_1.js CHANGED
@@ -4,6 +4,8 @@ exports.deserializeAws_json1_1GetEvaluationCommand = exports.deserializeAws_json
4
4
  exports.deserializeAws_json1_1UpdateMLModelCommand = exports.deserializeAws_json1_1UpdateEvaluationCommand = exports.deserializeAws_json1_1UpdateDataSourceCommand = exports.deserializeAws_json1_1UpdateBatchPredictionCommand = exports.deserializeAws_json1_1PredictCommand = exports.deserializeAws_json1_1GetMLModelCommand = void 0;
5
5
  const protocol_http_1 = require("@aws-sdk/protocol-http");
6
6
  const smithy_client_1 = require("@aws-sdk/smithy-client");
7
+ const MachineLearningServiceException_1 = require("../models/MachineLearningServiceException");
8
+ const models_0_1 = require("../models/models_0");
7
9
  const serializeAws_json1_1AddTagsCommand = async (input, context) => {
8
10
  const headers = {
9
11
  "content-type": "application/x-amz-json-1.1",
@@ -309,59 +311,28 @@ const deserializeAws_json1_1AddTagsCommandError = async (output, context) => {
309
311
  switch (errorCode) {
310
312
  case "InternalServerException":
311
313
  case "com.amazonaws.machinelearning#InternalServerException":
312
- response = {
313
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
314
- name: errorCode,
315
- $metadata: deserializeMetadata(output),
316
- };
317
- break;
314
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
318
315
  case "InvalidInputException":
319
316
  case "com.amazonaws.machinelearning#InvalidInputException":
320
- response = {
321
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
322
- name: errorCode,
323
- $metadata: deserializeMetadata(output),
324
- };
325
- break;
317
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
326
318
  case "InvalidTagException":
327
319
  case "com.amazonaws.machinelearning#InvalidTagException":
328
- response = {
329
- ...(await deserializeAws_json1_1InvalidTagExceptionResponse(parsedOutput, context)),
330
- name: errorCode,
331
- $metadata: deserializeMetadata(output),
332
- };
333
- break;
320
+ throw await deserializeAws_json1_1InvalidTagExceptionResponse(parsedOutput, context);
334
321
  case "ResourceNotFoundException":
335
322
  case "com.amazonaws.machinelearning#ResourceNotFoundException":
336
- response = {
337
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
338
- name: errorCode,
339
- $metadata: deserializeMetadata(output),
340
- };
341
- break;
323
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
342
324
  case "TagLimitExceededException":
343
325
  case "com.amazonaws.machinelearning#TagLimitExceededException":
344
- response = {
345
- ...(await deserializeAws_json1_1TagLimitExceededExceptionResponse(parsedOutput, context)),
346
- name: errorCode,
347
- $metadata: deserializeMetadata(output),
348
- };
349
- break;
326
+ throw await deserializeAws_json1_1TagLimitExceededExceptionResponse(parsedOutput, context);
350
327
  default:
351
328
  const parsedBody = parsedOutput.body;
352
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
353
- response = {
354
- ...parsedBody,
355
- name: `${errorCode}`,
356
- message: parsedBody.message || parsedBody.Message || errorCode,
329
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
330
+ name: parsedBody.code || parsedBody.Code || errorCode,
357
331
  $fault: "client",
358
332
  $metadata: deserializeMetadata(output),
359
- };
333
+ });
334
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
360
335
  }
361
- const message = response.message || response.Message || errorCode;
362
- response.message = message;
363
- delete response.Message;
364
- return Promise.reject(Object.assign(new Error(message), response));
365
336
  };
366
337
  const deserializeAws_json1_1CreateBatchPredictionCommand = async (output, context) => {
367
338
  if (output.statusCode >= 300) {
@@ -388,43 +359,22 @@ const deserializeAws_json1_1CreateBatchPredictionCommandError = async (output, c
388
359
  switch (errorCode) {
389
360
  case "IdempotentParameterMismatchException":
390
361
  case "com.amazonaws.machinelearning#IdempotentParameterMismatchException":
391
- response = {
392
- ...(await deserializeAws_json1_1IdempotentParameterMismatchExceptionResponse(parsedOutput, context)),
393
- name: errorCode,
394
- $metadata: deserializeMetadata(output),
395
- };
396
- break;
362
+ throw await deserializeAws_json1_1IdempotentParameterMismatchExceptionResponse(parsedOutput, context);
397
363
  case "InternalServerException":
398
364
  case "com.amazonaws.machinelearning#InternalServerException":
399
- response = {
400
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
401
- name: errorCode,
402
- $metadata: deserializeMetadata(output),
403
- };
404
- break;
365
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
405
366
  case "InvalidInputException":
406
367
  case "com.amazonaws.machinelearning#InvalidInputException":
407
- response = {
408
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
409
- name: errorCode,
410
- $metadata: deserializeMetadata(output),
411
- };
412
- break;
368
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
413
369
  default:
414
370
  const parsedBody = parsedOutput.body;
415
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
416
- response = {
417
- ...parsedBody,
418
- name: `${errorCode}`,
419
- message: parsedBody.message || parsedBody.Message || errorCode,
371
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
372
+ name: parsedBody.code || parsedBody.Code || errorCode,
420
373
  $fault: "client",
421
374
  $metadata: deserializeMetadata(output),
422
- };
375
+ });
376
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
423
377
  }
424
- const message = response.message || response.Message || errorCode;
425
- response.message = message;
426
- delete response.Message;
427
- return Promise.reject(Object.assign(new Error(message), response));
428
378
  };
429
379
  const deserializeAws_json1_1CreateDataSourceFromRDSCommand = async (output, context) => {
430
380
  if (output.statusCode >= 300) {
@@ -451,43 +401,22 @@ const deserializeAws_json1_1CreateDataSourceFromRDSCommandError = async (output,
451
401
  switch (errorCode) {
452
402
  case "IdempotentParameterMismatchException":
453
403
  case "com.amazonaws.machinelearning#IdempotentParameterMismatchException":
454
- response = {
455
- ...(await deserializeAws_json1_1IdempotentParameterMismatchExceptionResponse(parsedOutput, context)),
456
- name: errorCode,
457
- $metadata: deserializeMetadata(output),
458
- };
459
- break;
404
+ throw await deserializeAws_json1_1IdempotentParameterMismatchExceptionResponse(parsedOutput, context);
460
405
  case "InternalServerException":
461
406
  case "com.amazonaws.machinelearning#InternalServerException":
462
- response = {
463
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
464
- name: errorCode,
465
- $metadata: deserializeMetadata(output),
466
- };
467
- break;
407
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
468
408
  case "InvalidInputException":
469
409
  case "com.amazonaws.machinelearning#InvalidInputException":
470
- response = {
471
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
472
- name: errorCode,
473
- $metadata: deserializeMetadata(output),
474
- };
475
- break;
410
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
476
411
  default:
477
412
  const parsedBody = parsedOutput.body;
478
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
479
- response = {
480
- ...parsedBody,
481
- name: `${errorCode}`,
482
- message: parsedBody.message || parsedBody.Message || errorCode,
413
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
414
+ name: parsedBody.code || parsedBody.Code || errorCode,
483
415
  $fault: "client",
484
416
  $metadata: deserializeMetadata(output),
485
- };
417
+ });
418
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
486
419
  }
487
- const message = response.message || response.Message || errorCode;
488
- response.message = message;
489
- delete response.Message;
490
- return Promise.reject(Object.assign(new Error(message), response));
491
420
  };
492
421
  const deserializeAws_json1_1CreateDataSourceFromRedshiftCommand = async (output, context) => {
493
422
  if (output.statusCode >= 300) {
@@ -514,43 +443,22 @@ const deserializeAws_json1_1CreateDataSourceFromRedshiftCommandError = async (ou
514
443
  switch (errorCode) {
515
444
  case "IdempotentParameterMismatchException":
516
445
  case "com.amazonaws.machinelearning#IdempotentParameterMismatchException":
517
- response = {
518
- ...(await deserializeAws_json1_1IdempotentParameterMismatchExceptionResponse(parsedOutput, context)),
519
- name: errorCode,
520
- $metadata: deserializeMetadata(output),
521
- };
522
- break;
446
+ throw await deserializeAws_json1_1IdempotentParameterMismatchExceptionResponse(parsedOutput, context);
523
447
  case "InternalServerException":
524
448
  case "com.amazonaws.machinelearning#InternalServerException":
525
- response = {
526
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
527
- name: errorCode,
528
- $metadata: deserializeMetadata(output),
529
- };
530
- break;
449
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
531
450
  case "InvalidInputException":
532
451
  case "com.amazonaws.machinelearning#InvalidInputException":
533
- response = {
534
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
535
- name: errorCode,
536
- $metadata: deserializeMetadata(output),
537
- };
538
- break;
452
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
539
453
  default:
540
454
  const parsedBody = parsedOutput.body;
541
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
542
- response = {
543
- ...parsedBody,
544
- name: `${errorCode}`,
545
- message: parsedBody.message || parsedBody.Message || errorCode,
455
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
456
+ name: parsedBody.code || parsedBody.Code || errorCode,
546
457
  $fault: "client",
547
458
  $metadata: deserializeMetadata(output),
548
- };
459
+ });
460
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
549
461
  }
550
- const message = response.message || response.Message || errorCode;
551
- response.message = message;
552
- delete response.Message;
553
- return Promise.reject(Object.assign(new Error(message), response));
554
462
  };
555
463
  const deserializeAws_json1_1CreateDataSourceFromS3Command = async (output, context) => {
556
464
  if (output.statusCode >= 300) {
@@ -577,43 +485,22 @@ const deserializeAws_json1_1CreateDataSourceFromS3CommandError = async (output,
577
485
  switch (errorCode) {
578
486
  case "IdempotentParameterMismatchException":
579
487
  case "com.amazonaws.machinelearning#IdempotentParameterMismatchException":
580
- response = {
581
- ...(await deserializeAws_json1_1IdempotentParameterMismatchExceptionResponse(parsedOutput, context)),
582
- name: errorCode,
583
- $metadata: deserializeMetadata(output),
584
- };
585
- break;
488
+ throw await deserializeAws_json1_1IdempotentParameterMismatchExceptionResponse(parsedOutput, context);
586
489
  case "InternalServerException":
587
490
  case "com.amazonaws.machinelearning#InternalServerException":
588
- response = {
589
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
590
- name: errorCode,
591
- $metadata: deserializeMetadata(output),
592
- };
593
- break;
491
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
594
492
  case "InvalidInputException":
595
493
  case "com.amazonaws.machinelearning#InvalidInputException":
596
- response = {
597
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
598
- name: errorCode,
599
- $metadata: deserializeMetadata(output),
600
- };
601
- break;
494
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
602
495
  default:
603
496
  const parsedBody = parsedOutput.body;
604
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
605
- response = {
606
- ...parsedBody,
607
- name: `${errorCode}`,
608
- message: parsedBody.message || parsedBody.Message || errorCode,
497
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
498
+ name: parsedBody.code || parsedBody.Code || errorCode,
609
499
  $fault: "client",
610
500
  $metadata: deserializeMetadata(output),
611
- };
501
+ });
502
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
612
503
  }
613
- const message = response.message || response.Message || errorCode;
614
- response.message = message;
615
- delete response.Message;
616
- return Promise.reject(Object.assign(new Error(message), response));
617
504
  };
618
505
  const deserializeAws_json1_1CreateEvaluationCommand = async (output, context) => {
619
506
  if (output.statusCode >= 300) {
@@ -640,43 +527,22 @@ const deserializeAws_json1_1CreateEvaluationCommandError = async (output, contex
640
527
  switch (errorCode) {
641
528
  case "IdempotentParameterMismatchException":
642
529
  case "com.amazonaws.machinelearning#IdempotentParameterMismatchException":
643
- response = {
644
- ...(await deserializeAws_json1_1IdempotentParameterMismatchExceptionResponse(parsedOutput, context)),
645
- name: errorCode,
646
- $metadata: deserializeMetadata(output),
647
- };
648
- break;
530
+ throw await deserializeAws_json1_1IdempotentParameterMismatchExceptionResponse(parsedOutput, context);
649
531
  case "InternalServerException":
650
532
  case "com.amazonaws.machinelearning#InternalServerException":
651
- response = {
652
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
653
- name: errorCode,
654
- $metadata: deserializeMetadata(output),
655
- };
656
- break;
533
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
657
534
  case "InvalidInputException":
658
535
  case "com.amazonaws.machinelearning#InvalidInputException":
659
- response = {
660
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
661
- name: errorCode,
662
- $metadata: deserializeMetadata(output),
663
- };
664
- break;
536
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
665
537
  default:
666
538
  const parsedBody = parsedOutput.body;
667
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
668
- response = {
669
- ...parsedBody,
670
- name: `${errorCode}`,
671
- message: parsedBody.message || parsedBody.Message || errorCode,
539
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
540
+ name: parsedBody.code || parsedBody.Code || errorCode,
672
541
  $fault: "client",
673
542
  $metadata: deserializeMetadata(output),
674
- };
543
+ });
544
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
675
545
  }
676
- const message = response.message || response.Message || errorCode;
677
- response.message = message;
678
- delete response.Message;
679
- return Promise.reject(Object.assign(new Error(message), response));
680
546
  };
681
547
  const deserializeAws_json1_1CreateMLModelCommand = async (output, context) => {
682
548
  if (output.statusCode >= 300) {
@@ -703,43 +569,22 @@ const deserializeAws_json1_1CreateMLModelCommandError = async (output, context)
703
569
  switch (errorCode) {
704
570
  case "IdempotentParameterMismatchException":
705
571
  case "com.amazonaws.machinelearning#IdempotentParameterMismatchException":
706
- response = {
707
- ...(await deserializeAws_json1_1IdempotentParameterMismatchExceptionResponse(parsedOutput, context)),
708
- name: errorCode,
709
- $metadata: deserializeMetadata(output),
710
- };
711
- break;
572
+ throw await deserializeAws_json1_1IdempotentParameterMismatchExceptionResponse(parsedOutput, context);
712
573
  case "InternalServerException":
713
574
  case "com.amazonaws.machinelearning#InternalServerException":
714
- response = {
715
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
716
- name: errorCode,
717
- $metadata: deserializeMetadata(output),
718
- };
719
- break;
575
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
720
576
  case "InvalidInputException":
721
577
  case "com.amazonaws.machinelearning#InvalidInputException":
722
- response = {
723
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
724
- name: errorCode,
725
- $metadata: deserializeMetadata(output),
726
- };
727
- break;
578
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
728
579
  default:
729
580
  const parsedBody = parsedOutput.body;
730
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
731
- response = {
732
- ...parsedBody,
733
- name: `${errorCode}`,
734
- message: parsedBody.message || parsedBody.Message || errorCode,
581
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
582
+ name: parsedBody.code || parsedBody.Code || errorCode,
735
583
  $fault: "client",
736
584
  $metadata: deserializeMetadata(output),
737
- };
585
+ });
586
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
738
587
  }
739
- const message = response.message || response.Message || errorCode;
740
- response.message = message;
741
- delete response.Message;
742
- return Promise.reject(Object.assign(new Error(message), response));
743
588
  };
744
589
  const deserializeAws_json1_1CreateRealtimeEndpointCommand = async (output, context) => {
745
590
  if (output.statusCode >= 300) {
@@ -766,43 +611,22 @@ const deserializeAws_json1_1CreateRealtimeEndpointCommandError = async (output,
766
611
  switch (errorCode) {
767
612
  case "InternalServerException":
768
613
  case "com.amazonaws.machinelearning#InternalServerException":
769
- response = {
770
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
771
- name: errorCode,
772
- $metadata: deserializeMetadata(output),
773
- };
774
- break;
614
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
775
615
  case "InvalidInputException":
776
616
  case "com.amazonaws.machinelearning#InvalidInputException":
777
- response = {
778
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
779
- name: errorCode,
780
- $metadata: deserializeMetadata(output),
781
- };
782
- break;
617
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
783
618
  case "ResourceNotFoundException":
784
619
  case "com.amazonaws.machinelearning#ResourceNotFoundException":
785
- response = {
786
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
787
- name: errorCode,
788
- $metadata: deserializeMetadata(output),
789
- };
790
- break;
620
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
791
621
  default:
792
622
  const parsedBody = parsedOutput.body;
793
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
794
- response = {
795
- ...parsedBody,
796
- name: `${errorCode}`,
797
- message: parsedBody.message || parsedBody.Message || errorCode,
623
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
624
+ name: parsedBody.code || parsedBody.Code || errorCode,
798
625
  $fault: "client",
799
626
  $metadata: deserializeMetadata(output),
800
- };
627
+ });
628
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
801
629
  }
802
- const message = response.message || response.Message || errorCode;
803
- response.message = message;
804
- delete response.Message;
805
- return Promise.reject(Object.assign(new Error(message), response));
806
630
  };
807
631
  const deserializeAws_json1_1DeleteBatchPredictionCommand = async (output, context) => {
808
632
  if (output.statusCode >= 300) {
@@ -829,43 +653,22 @@ const deserializeAws_json1_1DeleteBatchPredictionCommandError = async (output, c
829
653
  switch (errorCode) {
830
654
  case "InternalServerException":
831
655
  case "com.amazonaws.machinelearning#InternalServerException":
832
- response = {
833
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
834
- name: errorCode,
835
- $metadata: deserializeMetadata(output),
836
- };
837
- break;
656
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
838
657
  case "InvalidInputException":
839
658
  case "com.amazonaws.machinelearning#InvalidInputException":
840
- response = {
841
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
842
- name: errorCode,
843
- $metadata: deserializeMetadata(output),
844
- };
845
- break;
659
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
846
660
  case "ResourceNotFoundException":
847
661
  case "com.amazonaws.machinelearning#ResourceNotFoundException":
848
- response = {
849
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
850
- name: errorCode,
851
- $metadata: deserializeMetadata(output),
852
- };
853
- break;
662
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
854
663
  default:
855
664
  const parsedBody = parsedOutput.body;
856
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
857
- response = {
858
- ...parsedBody,
859
- name: `${errorCode}`,
860
- message: parsedBody.message || parsedBody.Message || errorCode,
665
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
666
+ name: parsedBody.code || parsedBody.Code || errorCode,
861
667
  $fault: "client",
862
668
  $metadata: deserializeMetadata(output),
863
- };
669
+ });
670
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
864
671
  }
865
- const message = response.message || response.Message || errorCode;
866
- response.message = message;
867
- delete response.Message;
868
- return Promise.reject(Object.assign(new Error(message), response));
869
672
  };
870
673
  const deserializeAws_json1_1DeleteDataSourceCommand = async (output, context) => {
871
674
  if (output.statusCode >= 300) {
@@ -892,43 +695,22 @@ const deserializeAws_json1_1DeleteDataSourceCommandError = async (output, contex
892
695
  switch (errorCode) {
893
696
  case "InternalServerException":
894
697
  case "com.amazonaws.machinelearning#InternalServerException":
895
- response = {
896
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
897
- name: errorCode,
898
- $metadata: deserializeMetadata(output),
899
- };
900
- break;
698
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
901
699
  case "InvalidInputException":
902
700
  case "com.amazonaws.machinelearning#InvalidInputException":
903
- response = {
904
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
905
- name: errorCode,
906
- $metadata: deserializeMetadata(output),
907
- };
908
- break;
701
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
909
702
  case "ResourceNotFoundException":
910
703
  case "com.amazonaws.machinelearning#ResourceNotFoundException":
911
- response = {
912
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
913
- name: errorCode,
914
- $metadata: deserializeMetadata(output),
915
- };
916
- break;
704
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
917
705
  default:
918
706
  const parsedBody = parsedOutput.body;
919
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
920
- response = {
921
- ...parsedBody,
922
- name: `${errorCode}`,
923
- message: parsedBody.message || parsedBody.Message || errorCode,
707
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
708
+ name: parsedBody.code || parsedBody.Code || errorCode,
924
709
  $fault: "client",
925
710
  $metadata: deserializeMetadata(output),
926
- };
711
+ });
712
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
927
713
  }
928
- const message = response.message || response.Message || errorCode;
929
- response.message = message;
930
- delete response.Message;
931
- return Promise.reject(Object.assign(new Error(message), response));
932
714
  };
933
715
  const deserializeAws_json1_1DeleteEvaluationCommand = async (output, context) => {
934
716
  if (output.statusCode >= 300) {
@@ -955,43 +737,22 @@ const deserializeAws_json1_1DeleteEvaluationCommandError = async (output, contex
955
737
  switch (errorCode) {
956
738
  case "InternalServerException":
957
739
  case "com.amazonaws.machinelearning#InternalServerException":
958
- response = {
959
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
960
- name: errorCode,
961
- $metadata: deserializeMetadata(output),
962
- };
963
- break;
740
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
964
741
  case "InvalidInputException":
965
742
  case "com.amazonaws.machinelearning#InvalidInputException":
966
- response = {
967
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
968
- name: errorCode,
969
- $metadata: deserializeMetadata(output),
970
- };
971
- break;
743
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
972
744
  case "ResourceNotFoundException":
973
745
  case "com.amazonaws.machinelearning#ResourceNotFoundException":
974
- response = {
975
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
976
- name: errorCode,
977
- $metadata: deserializeMetadata(output),
978
- };
979
- break;
746
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
980
747
  default:
981
748
  const parsedBody = parsedOutput.body;
982
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
983
- response = {
984
- ...parsedBody,
985
- name: `${errorCode}`,
986
- message: parsedBody.message || parsedBody.Message || errorCode,
749
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
750
+ name: parsedBody.code || parsedBody.Code || errorCode,
987
751
  $fault: "client",
988
752
  $metadata: deserializeMetadata(output),
989
- };
753
+ });
754
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
990
755
  }
991
- const message = response.message || response.Message || errorCode;
992
- response.message = message;
993
- delete response.Message;
994
- return Promise.reject(Object.assign(new Error(message), response));
995
756
  };
996
757
  const deserializeAws_json1_1DeleteMLModelCommand = async (output, context) => {
997
758
  if (output.statusCode >= 300) {
@@ -1018,43 +779,22 @@ const deserializeAws_json1_1DeleteMLModelCommandError = async (output, context)
1018
779
  switch (errorCode) {
1019
780
  case "InternalServerException":
1020
781
  case "com.amazonaws.machinelearning#InternalServerException":
1021
- response = {
1022
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
1023
- name: errorCode,
1024
- $metadata: deserializeMetadata(output),
1025
- };
1026
- break;
782
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
1027
783
  case "InvalidInputException":
1028
784
  case "com.amazonaws.machinelearning#InvalidInputException":
1029
- response = {
1030
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
1031
- name: errorCode,
1032
- $metadata: deserializeMetadata(output),
1033
- };
1034
- break;
785
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
1035
786
  case "ResourceNotFoundException":
1036
787
  case "com.amazonaws.machinelearning#ResourceNotFoundException":
1037
- response = {
1038
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1039
- name: errorCode,
1040
- $metadata: deserializeMetadata(output),
1041
- };
1042
- break;
788
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
1043
789
  default:
1044
790
  const parsedBody = parsedOutput.body;
1045
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1046
- response = {
1047
- ...parsedBody,
1048
- name: `${errorCode}`,
1049
- message: parsedBody.message || parsedBody.Message || errorCode,
791
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
792
+ name: parsedBody.code || parsedBody.Code || errorCode,
1050
793
  $fault: "client",
1051
794
  $metadata: deserializeMetadata(output),
1052
- };
795
+ });
796
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1053
797
  }
1054
- const message = response.message || response.Message || errorCode;
1055
- response.message = message;
1056
- delete response.Message;
1057
- return Promise.reject(Object.assign(new Error(message), response));
1058
798
  };
1059
799
  const deserializeAws_json1_1DeleteRealtimeEndpointCommand = async (output, context) => {
1060
800
  if (output.statusCode >= 300) {
@@ -1081,43 +821,22 @@ const deserializeAws_json1_1DeleteRealtimeEndpointCommandError = async (output,
1081
821
  switch (errorCode) {
1082
822
  case "InternalServerException":
1083
823
  case "com.amazonaws.machinelearning#InternalServerException":
1084
- response = {
1085
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
1086
- name: errorCode,
1087
- $metadata: deserializeMetadata(output),
1088
- };
1089
- break;
824
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
1090
825
  case "InvalidInputException":
1091
826
  case "com.amazonaws.machinelearning#InvalidInputException":
1092
- response = {
1093
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
1094
- name: errorCode,
1095
- $metadata: deserializeMetadata(output),
1096
- };
1097
- break;
827
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
1098
828
  case "ResourceNotFoundException":
1099
829
  case "com.amazonaws.machinelearning#ResourceNotFoundException":
1100
- response = {
1101
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1102
- name: errorCode,
1103
- $metadata: deserializeMetadata(output),
1104
- };
1105
- break;
830
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
1106
831
  default:
1107
832
  const parsedBody = parsedOutput.body;
1108
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1109
- response = {
1110
- ...parsedBody,
1111
- name: `${errorCode}`,
1112
- message: parsedBody.message || parsedBody.Message || errorCode,
833
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
834
+ name: parsedBody.code || parsedBody.Code || errorCode,
1113
835
  $fault: "client",
1114
836
  $metadata: deserializeMetadata(output),
1115
- };
837
+ });
838
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1116
839
  }
1117
- const message = response.message || response.Message || errorCode;
1118
- response.message = message;
1119
- delete response.Message;
1120
- return Promise.reject(Object.assign(new Error(message), response));
1121
840
  };
1122
841
  const deserializeAws_json1_1DeleteTagsCommand = async (output, context) => {
1123
842
  if (output.statusCode >= 300) {
@@ -1144,51 +863,25 @@ const deserializeAws_json1_1DeleteTagsCommandError = async (output, context) =>
1144
863
  switch (errorCode) {
1145
864
  case "InternalServerException":
1146
865
  case "com.amazonaws.machinelearning#InternalServerException":
1147
- response = {
1148
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
1149
- name: errorCode,
1150
- $metadata: deserializeMetadata(output),
1151
- };
1152
- break;
866
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
1153
867
  case "InvalidInputException":
1154
868
  case "com.amazonaws.machinelearning#InvalidInputException":
1155
- response = {
1156
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
1157
- name: errorCode,
1158
- $metadata: deserializeMetadata(output),
1159
- };
1160
- break;
869
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
1161
870
  case "InvalidTagException":
1162
871
  case "com.amazonaws.machinelearning#InvalidTagException":
1163
- response = {
1164
- ...(await deserializeAws_json1_1InvalidTagExceptionResponse(parsedOutput, context)),
1165
- name: errorCode,
1166
- $metadata: deserializeMetadata(output),
1167
- };
1168
- break;
872
+ throw await deserializeAws_json1_1InvalidTagExceptionResponse(parsedOutput, context);
1169
873
  case "ResourceNotFoundException":
1170
874
  case "com.amazonaws.machinelearning#ResourceNotFoundException":
1171
- response = {
1172
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1173
- name: errorCode,
1174
- $metadata: deserializeMetadata(output),
1175
- };
1176
- break;
875
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
1177
876
  default:
1178
877
  const parsedBody = parsedOutput.body;
1179
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1180
- response = {
1181
- ...parsedBody,
1182
- name: `${errorCode}`,
1183
- message: parsedBody.message || parsedBody.Message || errorCode,
878
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
879
+ name: parsedBody.code || parsedBody.Code || errorCode,
1184
880
  $fault: "client",
1185
881
  $metadata: deserializeMetadata(output),
1186
- };
882
+ });
883
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1187
884
  }
1188
- const message = response.message || response.Message || errorCode;
1189
- response.message = message;
1190
- delete response.Message;
1191
- return Promise.reject(Object.assign(new Error(message), response));
1192
885
  };
1193
886
  const deserializeAws_json1_1DescribeBatchPredictionsCommand = async (output, context) => {
1194
887
  if (output.statusCode >= 300) {
@@ -1215,35 +908,19 @@ const deserializeAws_json1_1DescribeBatchPredictionsCommandError = async (output
1215
908
  switch (errorCode) {
1216
909
  case "InternalServerException":
1217
910
  case "com.amazonaws.machinelearning#InternalServerException":
1218
- response = {
1219
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
1220
- name: errorCode,
1221
- $metadata: deserializeMetadata(output),
1222
- };
1223
- break;
911
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
1224
912
  case "InvalidInputException":
1225
913
  case "com.amazonaws.machinelearning#InvalidInputException":
1226
- response = {
1227
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
1228
- name: errorCode,
1229
- $metadata: deserializeMetadata(output),
1230
- };
1231
- break;
914
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
1232
915
  default:
1233
916
  const parsedBody = parsedOutput.body;
1234
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1235
- response = {
1236
- ...parsedBody,
1237
- name: `${errorCode}`,
1238
- message: parsedBody.message || parsedBody.Message || errorCode,
917
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
918
+ name: parsedBody.code || parsedBody.Code || errorCode,
1239
919
  $fault: "client",
1240
920
  $metadata: deserializeMetadata(output),
1241
- };
921
+ });
922
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1242
923
  }
1243
- const message = response.message || response.Message || errorCode;
1244
- response.message = message;
1245
- delete response.Message;
1246
- return Promise.reject(Object.assign(new Error(message), response));
1247
924
  };
1248
925
  const deserializeAws_json1_1DescribeDataSourcesCommand = async (output, context) => {
1249
926
  if (output.statusCode >= 300) {
@@ -1270,35 +947,19 @@ const deserializeAws_json1_1DescribeDataSourcesCommandError = async (output, con
1270
947
  switch (errorCode) {
1271
948
  case "InternalServerException":
1272
949
  case "com.amazonaws.machinelearning#InternalServerException":
1273
- response = {
1274
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
1275
- name: errorCode,
1276
- $metadata: deserializeMetadata(output),
1277
- };
1278
- break;
950
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
1279
951
  case "InvalidInputException":
1280
952
  case "com.amazonaws.machinelearning#InvalidInputException":
1281
- response = {
1282
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
1283
- name: errorCode,
1284
- $metadata: deserializeMetadata(output),
1285
- };
1286
- break;
953
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
1287
954
  default:
1288
955
  const parsedBody = parsedOutput.body;
1289
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1290
- response = {
1291
- ...parsedBody,
1292
- name: `${errorCode}`,
1293
- message: parsedBody.message || parsedBody.Message || errorCode,
956
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
957
+ name: parsedBody.code || parsedBody.Code || errorCode,
1294
958
  $fault: "client",
1295
959
  $metadata: deserializeMetadata(output),
1296
- };
960
+ });
961
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1297
962
  }
1298
- const message = response.message || response.Message || errorCode;
1299
- response.message = message;
1300
- delete response.Message;
1301
- return Promise.reject(Object.assign(new Error(message), response));
1302
963
  };
1303
964
  const deserializeAws_json1_1DescribeEvaluationsCommand = async (output, context) => {
1304
965
  if (output.statusCode >= 300) {
@@ -1325,35 +986,19 @@ const deserializeAws_json1_1DescribeEvaluationsCommandError = async (output, con
1325
986
  switch (errorCode) {
1326
987
  case "InternalServerException":
1327
988
  case "com.amazonaws.machinelearning#InternalServerException":
1328
- response = {
1329
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
1330
- name: errorCode,
1331
- $metadata: deserializeMetadata(output),
1332
- };
1333
- break;
989
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
1334
990
  case "InvalidInputException":
1335
991
  case "com.amazonaws.machinelearning#InvalidInputException":
1336
- response = {
1337
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
1338
- name: errorCode,
1339
- $metadata: deserializeMetadata(output),
1340
- };
1341
- break;
992
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
1342
993
  default:
1343
994
  const parsedBody = parsedOutput.body;
1344
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1345
- response = {
1346
- ...parsedBody,
1347
- name: `${errorCode}`,
1348
- message: parsedBody.message || parsedBody.Message || errorCode,
995
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
996
+ name: parsedBody.code || parsedBody.Code || errorCode,
1349
997
  $fault: "client",
1350
998
  $metadata: deserializeMetadata(output),
1351
- };
999
+ });
1000
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1352
1001
  }
1353
- const message = response.message || response.Message || errorCode;
1354
- response.message = message;
1355
- delete response.Message;
1356
- return Promise.reject(Object.assign(new Error(message), response));
1357
1002
  };
1358
1003
  const deserializeAws_json1_1DescribeMLModelsCommand = async (output, context) => {
1359
1004
  if (output.statusCode >= 300) {
@@ -1380,35 +1025,19 @@ const deserializeAws_json1_1DescribeMLModelsCommandError = async (output, contex
1380
1025
  switch (errorCode) {
1381
1026
  case "InternalServerException":
1382
1027
  case "com.amazonaws.machinelearning#InternalServerException":
1383
- response = {
1384
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
1385
- name: errorCode,
1386
- $metadata: deserializeMetadata(output),
1387
- };
1388
- break;
1028
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
1389
1029
  case "InvalidInputException":
1390
1030
  case "com.amazonaws.machinelearning#InvalidInputException":
1391
- response = {
1392
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
1393
- name: errorCode,
1394
- $metadata: deserializeMetadata(output),
1395
- };
1396
- break;
1031
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
1397
1032
  default:
1398
1033
  const parsedBody = parsedOutput.body;
1399
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1400
- response = {
1401
- ...parsedBody,
1402
- name: `${errorCode}`,
1403
- message: parsedBody.message || parsedBody.Message || errorCode,
1034
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
1035
+ name: parsedBody.code || parsedBody.Code || errorCode,
1404
1036
  $fault: "client",
1405
1037
  $metadata: deserializeMetadata(output),
1406
- };
1038
+ });
1039
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1407
1040
  }
1408
- const message = response.message || response.Message || errorCode;
1409
- response.message = message;
1410
- delete response.Message;
1411
- return Promise.reject(Object.assign(new Error(message), response));
1412
1041
  };
1413
1042
  const deserializeAws_json1_1DescribeTagsCommand = async (output, context) => {
1414
1043
  if (output.statusCode >= 300) {
@@ -1435,43 +1064,22 @@ const deserializeAws_json1_1DescribeTagsCommandError = async (output, context) =
1435
1064
  switch (errorCode) {
1436
1065
  case "InternalServerException":
1437
1066
  case "com.amazonaws.machinelearning#InternalServerException":
1438
- response = {
1439
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
1440
- name: errorCode,
1441
- $metadata: deserializeMetadata(output),
1442
- };
1443
- break;
1067
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
1444
1068
  case "InvalidInputException":
1445
1069
  case "com.amazonaws.machinelearning#InvalidInputException":
1446
- response = {
1447
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
1448
- name: errorCode,
1449
- $metadata: deserializeMetadata(output),
1450
- };
1451
- break;
1070
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
1452
1071
  case "ResourceNotFoundException":
1453
1072
  case "com.amazonaws.machinelearning#ResourceNotFoundException":
1454
- response = {
1455
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1456
- name: errorCode,
1457
- $metadata: deserializeMetadata(output),
1458
- };
1459
- break;
1073
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
1460
1074
  default:
1461
1075
  const parsedBody = parsedOutput.body;
1462
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1463
- response = {
1464
- ...parsedBody,
1465
- name: `${errorCode}`,
1466
- message: parsedBody.message || parsedBody.Message || errorCode,
1076
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
1077
+ name: parsedBody.code || parsedBody.Code || errorCode,
1467
1078
  $fault: "client",
1468
1079
  $metadata: deserializeMetadata(output),
1469
- };
1080
+ });
1081
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1470
1082
  }
1471
- const message = response.message || response.Message || errorCode;
1472
- response.message = message;
1473
- delete response.Message;
1474
- return Promise.reject(Object.assign(new Error(message), response));
1475
1083
  };
1476
1084
  const deserializeAws_json1_1GetBatchPredictionCommand = async (output, context) => {
1477
1085
  if (output.statusCode >= 300) {
@@ -1498,43 +1106,22 @@ const deserializeAws_json1_1GetBatchPredictionCommandError = async (output, cont
1498
1106
  switch (errorCode) {
1499
1107
  case "InternalServerException":
1500
1108
  case "com.amazonaws.machinelearning#InternalServerException":
1501
- response = {
1502
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
1503
- name: errorCode,
1504
- $metadata: deserializeMetadata(output),
1505
- };
1506
- break;
1109
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
1507
1110
  case "InvalidInputException":
1508
1111
  case "com.amazonaws.machinelearning#InvalidInputException":
1509
- response = {
1510
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
1511
- name: errorCode,
1512
- $metadata: deserializeMetadata(output),
1513
- };
1514
- break;
1112
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
1515
1113
  case "ResourceNotFoundException":
1516
1114
  case "com.amazonaws.machinelearning#ResourceNotFoundException":
1517
- response = {
1518
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1519
- name: errorCode,
1520
- $metadata: deserializeMetadata(output),
1521
- };
1522
- break;
1115
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
1523
1116
  default:
1524
1117
  const parsedBody = parsedOutput.body;
1525
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1526
- response = {
1527
- ...parsedBody,
1528
- name: `${errorCode}`,
1529
- message: parsedBody.message || parsedBody.Message || errorCode,
1118
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
1119
+ name: parsedBody.code || parsedBody.Code || errorCode,
1530
1120
  $fault: "client",
1531
1121
  $metadata: deserializeMetadata(output),
1532
- };
1122
+ });
1123
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1533
1124
  }
1534
- const message = response.message || response.Message || errorCode;
1535
- response.message = message;
1536
- delete response.Message;
1537
- return Promise.reject(Object.assign(new Error(message), response));
1538
1125
  };
1539
1126
  const deserializeAws_json1_1GetDataSourceCommand = async (output, context) => {
1540
1127
  if (output.statusCode >= 300) {
@@ -1561,43 +1148,22 @@ const deserializeAws_json1_1GetDataSourceCommandError = async (output, context)
1561
1148
  switch (errorCode) {
1562
1149
  case "InternalServerException":
1563
1150
  case "com.amazonaws.machinelearning#InternalServerException":
1564
- response = {
1565
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
1566
- name: errorCode,
1567
- $metadata: deserializeMetadata(output),
1568
- };
1569
- break;
1151
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
1570
1152
  case "InvalidInputException":
1571
1153
  case "com.amazonaws.machinelearning#InvalidInputException":
1572
- response = {
1573
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
1574
- name: errorCode,
1575
- $metadata: deserializeMetadata(output),
1576
- };
1577
- break;
1154
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
1578
1155
  case "ResourceNotFoundException":
1579
1156
  case "com.amazonaws.machinelearning#ResourceNotFoundException":
1580
- response = {
1581
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1582
- name: errorCode,
1583
- $metadata: deserializeMetadata(output),
1584
- };
1585
- break;
1157
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
1586
1158
  default:
1587
1159
  const parsedBody = parsedOutput.body;
1588
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1589
- response = {
1590
- ...parsedBody,
1591
- name: `${errorCode}`,
1592
- message: parsedBody.message || parsedBody.Message || errorCode,
1160
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
1161
+ name: parsedBody.code || parsedBody.Code || errorCode,
1593
1162
  $fault: "client",
1594
1163
  $metadata: deserializeMetadata(output),
1595
- };
1164
+ });
1165
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1596
1166
  }
1597
- const message = response.message || response.Message || errorCode;
1598
- response.message = message;
1599
- delete response.Message;
1600
- return Promise.reject(Object.assign(new Error(message), response));
1601
1167
  };
1602
1168
  const deserializeAws_json1_1GetEvaluationCommand = async (output, context) => {
1603
1169
  if (output.statusCode >= 300) {
@@ -1624,43 +1190,22 @@ const deserializeAws_json1_1GetEvaluationCommandError = async (output, context)
1624
1190
  switch (errorCode) {
1625
1191
  case "InternalServerException":
1626
1192
  case "com.amazonaws.machinelearning#InternalServerException":
1627
- response = {
1628
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
1629
- name: errorCode,
1630
- $metadata: deserializeMetadata(output),
1631
- };
1632
- break;
1193
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
1633
1194
  case "InvalidInputException":
1634
1195
  case "com.amazonaws.machinelearning#InvalidInputException":
1635
- response = {
1636
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
1637
- name: errorCode,
1638
- $metadata: deserializeMetadata(output),
1639
- };
1640
- break;
1196
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
1641
1197
  case "ResourceNotFoundException":
1642
1198
  case "com.amazonaws.machinelearning#ResourceNotFoundException":
1643
- response = {
1644
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1645
- name: errorCode,
1646
- $metadata: deserializeMetadata(output),
1647
- };
1648
- break;
1199
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
1649
1200
  default:
1650
1201
  const parsedBody = parsedOutput.body;
1651
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1652
- response = {
1653
- ...parsedBody,
1654
- name: `${errorCode}`,
1655
- message: parsedBody.message || parsedBody.Message || errorCode,
1202
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
1203
+ name: parsedBody.code || parsedBody.Code || errorCode,
1656
1204
  $fault: "client",
1657
1205
  $metadata: deserializeMetadata(output),
1658
- };
1206
+ });
1207
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1659
1208
  }
1660
- const message = response.message || response.Message || errorCode;
1661
- response.message = message;
1662
- delete response.Message;
1663
- return Promise.reject(Object.assign(new Error(message), response));
1664
1209
  };
1665
1210
  const deserializeAws_json1_1GetMLModelCommand = async (output, context) => {
1666
1211
  if (output.statusCode >= 300) {
@@ -1687,43 +1232,22 @@ const deserializeAws_json1_1GetMLModelCommandError = async (output, context) =>
1687
1232
  switch (errorCode) {
1688
1233
  case "InternalServerException":
1689
1234
  case "com.amazonaws.machinelearning#InternalServerException":
1690
- response = {
1691
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
1692
- name: errorCode,
1693
- $metadata: deserializeMetadata(output),
1694
- };
1695
- break;
1235
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
1696
1236
  case "InvalidInputException":
1697
1237
  case "com.amazonaws.machinelearning#InvalidInputException":
1698
- response = {
1699
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
1700
- name: errorCode,
1701
- $metadata: deserializeMetadata(output),
1702
- };
1703
- break;
1238
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
1704
1239
  case "ResourceNotFoundException":
1705
1240
  case "com.amazonaws.machinelearning#ResourceNotFoundException":
1706
- response = {
1707
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1708
- name: errorCode,
1709
- $metadata: deserializeMetadata(output),
1710
- };
1711
- break;
1241
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
1712
1242
  default:
1713
1243
  const parsedBody = parsedOutput.body;
1714
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1715
- response = {
1716
- ...parsedBody,
1717
- name: `${errorCode}`,
1718
- message: parsedBody.message || parsedBody.Message || errorCode,
1244
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
1245
+ name: parsedBody.code || parsedBody.Code || errorCode,
1719
1246
  $fault: "client",
1720
1247
  $metadata: deserializeMetadata(output),
1721
- };
1248
+ });
1249
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1722
1250
  }
1723
- const message = response.message || response.Message || errorCode;
1724
- response.message = message;
1725
- delete response.Message;
1726
- return Promise.reject(Object.assign(new Error(message), response));
1727
1251
  };
1728
1252
  const deserializeAws_json1_1PredictCommand = async (output, context) => {
1729
1253
  if (output.statusCode >= 300) {
@@ -1750,59 +1274,28 @@ const deserializeAws_json1_1PredictCommandError = async (output, context) => {
1750
1274
  switch (errorCode) {
1751
1275
  case "InternalServerException":
1752
1276
  case "com.amazonaws.machinelearning#InternalServerException":
1753
- response = {
1754
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
1755
- name: errorCode,
1756
- $metadata: deserializeMetadata(output),
1757
- };
1758
- break;
1277
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
1759
1278
  case "InvalidInputException":
1760
1279
  case "com.amazonaws.machinelearning#InvalidInputException":
1761
- response = {
1762
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
1763
- name: errorCode,
1764
- $metadata: deserializeMetadata(output),
1765
- };
1766
- break;
1280
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
1767
1281
  case "LimitExceededException":
1768
1282
  case "com.amazonaws.machinelearning#LimitExceededException":
1769
- response = {
1770
- ...(await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)),
1771
- name: errorCode,
1772
- $metadata: deserializeMetadata(output),
1773
- };
1774
- break;
1283
+ throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
1775
1284
  case "PredictorNotMountedException":
1776
1285
  case "com.amazonaws.machinelearning#PredictorNotMountedException":
1777
- response = {
1778
- ...(await deserializeAws_json1_1PredictorNotMountedExceptionResponse(parsedOutput, context)),
1779
- name: errorCode,
1780
- $metadata: deserializeMetadata(output),
1781
- };
1782
- break;
1286
+ throw await deserializeAws_json1_1PredictorNotMountedExceptionResponse(parsedOutput, context);
1783
1287
  case "ResourceNotFoundException":
1784
1288
  case "com.amazonaws.machinelearning#ResourceNotFoundException":
1785
- response = {
1786
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1787
- name: errorCode,
1788
- $metadata: deserializeMetadata(output),
1789
- };
1790
- break;
1289
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
1791
1290
  default:
1792
1291
  const parsedBody = parsedOutput.body;
1793
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1794
- response = {
1795
- ...parsedBody,
1796
- name: `${errorCode}`,
1797
- message: parsedBody.message || parsedBody.Message || errorCode,
1292
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
1293
+ name: parsedBody.code || parsedBody.Code || errorCode,
1798
1294
  $fault: "client",
1799
1295
  $metadata: deserializeMetadata(output),
1800
- };
1296
+ });
1297
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1801
1298
  }
1802
- const message = response.message || response.Message || errorCode;
1803
- response.message = message;
1804
- delete response.Message;
1805
- return Promise.reject(Object.assign(new Error(message), response));
1806
1299
  };
1807
1300
  const deserializeAws_json1_1UpdateBatchPredictionCommand = async (output, context) => {
1808
1301
  if (output.statusCode >= 300) {
@@ -1829,43 +1322,22 @@ const deserializeAws_json1_1UpdateBatchPredictionCommandError = async (output, c
1829
1322
  switch (errorCode) {
1830
1323
  case "InternalServerException":
1831
1324
  case "com.amazonaws.machinelearning#InternalServerException":
1832
- response = {
1833
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
1834
- name: errorCode,
1835
- $metadata: deserializeMetadata(output),
1836
- };
1837
- break;
1325
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
1838
1326
  case "InvalidInputException":
1839
1327
  case "com.amazonaws.machinelearning#InvalidInputException":
1840
- response = {
1841
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
1842
- name: errorCode,
1843
- $metadata: deserializeMetadata(output),
1844
- };
1845
- break;
1328
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
1846
1329
  case "ResourceNotFoundException":
1847
1330
  case "com.amazonaws.machinelearning#ResourceNotFoundException":
1848
- response = {
1849
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1850
- name: errorCode,
1851
- $metadata: deserializeMetadata(output),
1852
- };
1853
- break;
1331
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
1854
1332
  default:
1855
1333
  const parsedBody = parsedOutput.body;
1856
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1857
- response = {
1858
- ...parsedBody,
1859
- name: `${errorCode}`,
1860
- message: parsedBody.message || parsedBody.Message || errorCode,
1334
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
1335
+ name: parsedBody.code || parsedBody.Code || errorCode,
1861
1336
  $fault: "client",
1862
1337
  $metadata: deserializeMetadata(output),
1863
- };
1338
+ });
1339
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1864
1340
  }
1865
- const message = response.message || response.Message || errorCode;
1866
- response.message = message;
1867
- delete response.Message;
1868
- return Promise.reject(Object.assign(new Error(message), response));
1869
1341
  };
1870
1342
  const deserializeAws_json1_1UpdateDataSourceCommand = async (output, context) => {
1871
1343
  if (output.statusCode >= 300) {
@@ -1892,43 +1364,22 @@ const deserializeAws_json1_1UpdateDataSourceCommandError = async (output, contex
1892
1364
  switch (errorCode) {
1893
1365
  case "InternalServerException":
1894
1366
  case "com.amazonaws.machinelearning#InternalServerException":
1895
- response = {
1896
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
1897
- name: errorCode,
1898
- $metadata: deserializeMetadata(output),
1899
- };
1900
- break;
1367
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
1901
1368
  case "InvalidInputException":
1902
1369
  case "com.amazonaws.machinelearning#InvalidInputException":
1903
- response = {
1904
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
1905
- name: errorCode,
1906
- $metadata: deserializeMetadata(output),
1907
- };
1908
- break;
1370
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
1909
1371
  case "ResourceNotFoundException":
1910
1372
  case "com.amazonaws.machinelearning#ResourceNotFoundException":
1911
- response = {
1912
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1913
- name: errorCode,
1914
- $metadata: deserializeMetadata(output),
1915
- };
1916
- break;
1373
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
1917
1374
  default:
1918
1375
  const parsedBody = parsedOutput.body;
1919
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1920
- response = {
1921
- ...parsedBody,
1922
- name: `${errorCode}`,
1923
- message: parsedBody.message || parsedBody.Message || errorCode,
1376
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
1377
+ name: parsedBody.code || parsedBody.Code || errorCode,
1924
1378
  $fault: "client",
1925
1379
  $metadata: deserializeMetadata(output),
1926
- };
1380
+ });
1381
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1927
1382
  }
1928
- const message = response.message || response.Message || errorCode;
1929
- response.message = message;
1930
- delete response.Message;
1931
- return Promise.reject(Object.assign(new Error(message), response));
1932
1383
  };
1933
1384
  const deserializeAws_json1_1UpdateEvaluationCommand = async (output, context) => {
1934
1385
  if (output.statusCode >= 300) {
@@ -1955,43 +1406,22 @@ const deserializeAws_json1_1UpdateEvaluationCommandError = async (output, contex
1955
1406
  switch (errorCode) {
1956
1407
  case "InternalServerException":
1957
1408
  case "com.amazonaws.machinelearning#InternalServerException":
1958
- response = {
1959
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
1960
- name: errorCode,
1961
- $metadata: deserializeMetadata(output),
1962
- };
1963
- break;
1409
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
1964
1410
  case "InvalidInputException":
1965
1411
  case "com.amazonaws.machinelearning#InvalidInputException":
1966
- response = {
1967
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
1968
- name: errorCode,
1969
- $metadata: deserializeMetadata(output),
1970
- };
1971
- break;
1412
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
1972
1413
  case "ResourceNotFoundException":
1973
1414
  case "com.amazonaws.machinelearning#ResourceNotFoundException":
1974
- response = {
1975
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1976
- name: errorCode,
1977
- $metadata: deserializeMetadata(output),
1978
- };
1979
- break;
1415
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
1980
1416
  default:
1981
1417
  const parsedBody = parsedOutput.body;
1982
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1983
- response = {
1984
- ...parsedBody,
1985
- name: `${errorCode}`,
1986
- message: parsedBody.message || parsedBody.Message || errorCode,
1418
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
1419
+ name: parsedBody.code || parsedBody.Code || errorCode,
1987
1420
  $fault: "client",
1988
1421
  $metadata: deserializeMetadata(output),
1989
- };
1422
+ });
1423
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1990
1424
  }
1991
- const message = response.message || response.Message || errorCode;
1992
- response.message = message;
1993
- delete response.Message;
1994
- return Promise.reject(Object.assign(new Error(message), response));
1995
1425
  };
1996
1426
  const deserializeAws_json1_1UpdateMLModelCommand = async (output, context) => {
1997
1427
  if (output.statusCode >= 300) {
@@ -2018,131 +1448,94 @@ const deserializeAws_json1_1UpdateMLModelCommandError = async (output, context)
2018
1448
  switch (errorCode) {
2019
1449
  case "InternalServerException":
2020
1450
  case "com.amazonaws.machinelearning#InternalServerException":
2021
- response = {
2022
- ...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
2023
- name: errorCode,
2024
- $metadata: deserializeMetadata(output),
2025
- };
2026
- break;
1451
+ throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
2027
1452
  case "InvalidInputException":
2028
1453
  case "com.amazonaws.machinelearning#InvalidInputException":
2029
- response = {
2030
- ...(await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context)),
2031
- name: errorCode,
2032
- $metadata: deserializeMetadata(output),
2033
- };
2034
- break;
1454
+ throw await deserializeAws_json1_1InvalidInputExceptionResponse(parsedOutput, context);
2035
1455
  case "ResourceNotFoundException":
2036
1456
  case "com.amazonaws.machinelearning#ResourceNotFoundException":
2037
- response = {
2038
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
2039
- name: errorCode,
2040
- $metadata: deserializeMetadata(output),
2041
- };
2042
- break;
1457
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
2043
1458
  default:
2044
1459
  const parsedBody = parsedOutput.body;
2045
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2046
- response = {
2047
- ...parsedBody,
2048
- name: `${errorCode}`,
2049
- message: parsedBody.message || parsedBody.Message || errorCode,
1460
+ response = new MachineLearningServiceException_1.MachineLearningServiceException({
1461
+ name: parsedBody.code || parsedBody.Code || errorCode,
2050
1462
  $fault: "client",
2051
1463
  $metadata: deserializeMetadata(output),
2052
- };
1464
+ });
1465
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2053
1466
  }
2054
- const message = response.message || response.Message || errorCode;
2055
- response.message = message;
2056
- delete response.Message;
2057
- return Promise.reject(Object.assign(new Error(message), response));
2058
1467
  };
2059
1468
  const deserializeAws_json1_1IdempotentParameterMismatchExceptionResponse = async (parsedOutput, context) => {
2060
1469
  const body = parsedOutput.body;
2061
1470
  const deserialized = deserializeAws_json1_1IdempotentParameterMismatchException(body, context);
2062
- const contents = {
2063
- name: "IdempotentParameterMismatchException",
2064
- $fault: "client",
1471
+ const exception = new models_0_1.IdempotentParameterMismatchException({
2065
1472
  $metadata: deserializeMetadata(parsedOutput),
2066
1473
  ...deserialized,
2067
- };
2068
- return contents;
1474
+ });
1475
+ return smithy_client_1.decorateServiceException(exception, body);
2069
1476
  };
2070
1477
  const deserializeAws_json1_1InternalServerExceptionResponse = async (parsedOutput, context) => {
2071
1478
  const body = parsedOutput.body;
2072
1479
  const deserialized = deserializeAws_json1_1InternalServerException(body, context);
2073
- const contents = {
2074
- name: "InternalServerException",
2075
- $fault: "server",
1480
+ const exception = new models_0_1.InternalServerException({
2076
1481
  $metadata: deserializeMetadata(parsedOutput),
2077
1482
  ...deserialized,
2078
- };
2079
- return contents;
1483
+ });
1484
+ return smithy_client_1.decorateServiceException(exception, body);
2080
1485
  };
2081
1486
  const deserializeAws_json1_1InvalidInputExceptionResponse = async (parsedOutput, context) => {
2082
1487
  const body = parsedOutput.body;
2083
1488
  const deserialized = deserializeAws_json1_1InvalidInputException(body, context);
2084
- const contents = {
2085
- name: "InvalidInputException",
2086
- $fault: "client",
1489
+ const exception = new models_0_1.InvalidInputException({
2087
1490
  $metadata: deserializeMetadata(parsedOutput),
2088
1491
  ...deserialized,
2089
- };
2090
- return contents;
1492
+ });
1493
+ return smithy_client_1.decorateServiceException(exception, body);
2091
1494
  };
2092
1495
  const deserializeAws_json1_1InvalidTagExceptionResponse = async (parsedOutput, context) => {
2093
1496
  const body = parsedOutput.body;
2094
1497
  const deserialized = deserializeAws_json1_1InvalidTagException(body, context);
2095
- const contents = {
2096
- name: "InvalidTagException",
2097
- $fault: "client",
1498
+ const exception = new models_0_1.InvalidTagException({
2098
1499
  $metadata: deserializeMetadata(parsedOutput),
2099
1500
  ...deserialized,
2100
- };
2101
- return contents;
1501
+ });
1502
+ return smithy_client_1.decorateServiceException(exception, body);
2102
1503
  };
2103
1504
  const deserializeAws_json1_1LimitExceededExceptionResponse = async (parsedOutput, context) => {
2104
1505
  const body = parsedOutput.body;
2105
1506
  const deserialized = deserializeAws_json1_1LimitExceededException(body, context);
2106
- const contents = {
2107
- name: "LimitExceededException",
2108
- $fault: "client",
1507
+ const exception = new models_0_1.LimitExceededException({
2109
1508
  $metadata: deserializeMetadata(parsedOutput),
2110
1509
  ...deserialized,
2111
- };
2112
- return contents;
1510
+ });
1511
+ return smithy_client_1.decorateServiceException(exception, body);
2113
1512
  };
2114
1513
  const deserializeAws_json1_1PredictorNotMountedExceptionResponse = async (parsedOutput, context) => {
2115
1514
  const body = parsedOutput.body;
2116
1515
  const deserialized = deserializeAws_json1_1PredictorNotMountedException(body, context);
2117
- const contents = {
2118
- name: "PredictorNotMountedException",
2119
- $fault: "client",
1516
+ const exception = new models_0_1.PredictorNotMountedException({
2120
1517
  $metadata: deserializeMetadata(parsedOutput),
2121
1518
  ...deserialized,
2122
- };
2123
- return contents;
1519
+ });
1520
+ return smithy_client_1.decorateServiceException(exception, body);
2124
1521
  };
2125
1522
  const deserializeAws_json1_1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
2126
1523
  const body = parsedOutput.body;
2127
1524
  const deserialized = deserializeAws_json1_1ResourceNotFoundException(body, context);
2128
- const contents = {
2129
- name: "ResourceNotFoundException",
2130
- $fault: "client",
1525
+ const exception = new models_0_1.ResourceNotFoundException({
2131
1526
  $metadata: deserializeMetadata(parsedOutput),
2132
1527
  ...deserialized,
2133
- };
2134
- return contents;
1528
+ });
1529
+ return smithy_client_1.decorateServiceException(exception, body);
2135
1530
  };
2136
1531
  const deserializeAws_json1_1TagLimitExceededExceptionResponse = async (parsedOutput, context) => {
2137
1532
  const body = parsedOutput.body;
2138
1533
  const deserialized = deserializeAws_json1_1TagLimitExceededException(body, context);
2139
- const contents = {
2140
- name: "TagLimitExceededException",
2141
- $fault: "client",
1534
+ const exception = new models_0_1.TagLimitExceededException({
2142
1535
  $metadata: deserializeMetadata(parsedOutput),
2143
1536
  ...deserialized,
2144
- };
2145
- return contents;
1537
+ });
1538
+ return smithy_client_1.decorateServiceException(exception, body);
2146
1539
  };
2147
1540
  const serializeAws_json1_1AddTagsInput = (input, context) => {
2148
1541
  return {
@@ -2569,7 +1962,7 @@ const deserializeAws_json1_1BatchPrediction = (output, context) => {
2569
1962
  };
2570
1963
  };
2571
1964
  const deserializeAws_json1_1BatchPredictions = (output, context) => {
2572
- return (output || [])
1965
+ const retVal = (output || [])
2573
1966
  .filter((e) => e != null)
2574
1967
  .map((entry) => {
2575
1968
  if (entry === null) {
@@ -2577,6 +1970,7 @@ const deserializeAws_json1_1BatchPredictions = (output, context) => {
2577
1970
  }
2578
1971
  return deserializeAws_json1_1BatchPrediction(entry, context);
2579
1972
  });
1973
+ return retVal;
2580
1974
  };
2581
1975
  const deserializeAws_json1_1CreateBatchPredictionOutput = (output, context) => {
2582
1976
  return {
@@ -2651,7 +2045,7 @@ const deserializeAws_json1_1DataSource = (output, context) => {
2651
2045
  };
2652
2046
  };
2653
2047
  const deserializeAws_json1_1DataSources = (output, context) => {
2654
- return (output || [])
2048
+ const retVal = (output || [])
2655
2049
  .filter((e) => e != null)
2656
2050
  .map((entry) => {
2657
2051
  if (entry === null) {
@@ -2659,6 +2053,7 @@ const deserializeAws_json1_1DataSources = (output, context) => {
2659
2053
  }
2660
2054
  return deserializeAws_json1_1DataSource(entry, context);
2661
2055
  });
2056
+ return retVal;
2662
2057
  };
2663
2058
  const deserializeAws_json1_1DeleteBatchPredictionOutput = (output, context) => {
2664
2059
  return {
@@ -2775,7 +2170,7 @@ const deserializeAws_json1_1Evaluation = (output, context) => {
2775
2170
  };
2776
2171
  };
2777
2172
  const deserializeAws_json1_1Evaluations = (output, context) => {
2778
- return (output || [])
2173
+ const retVal = (output || [])
2779
2174
  .filter((e) => e != null)
2780
2175
  .map((entry) => {
2781
2176
  if (entry === null) {
@@ -2783,6 +2178,7 @@ const deserializeAws_json1_1Evaluations = (output, context) => {
2783
2178
  }
2784
2179
  return deserializeAws_json1_1Evaluation(entry, context);
2785
2180
  });
2181
+ return retVal;
2786
2182
  };
2787
2183
  const deserializeAws_json1_1GetBatchPredictionOutput = (output, context) => {
2788
2184
  return {
@@ -2984,7 +2380,7 @@ const deserializeAws_json1_1MLModel = (output, context) => {
2984
2380
  };
2985
2381
  };
2986
2382
  const deserializeAws_json1_1MLModels = (output, context) => {
2987
- return (output || [])
2383
+ const retVal = (output || [])
2988
2384
  .filter((e) => e != null)
2989
2385
  .map((entry) => {
2990
2386
  if (entry === null) {
@@ -2992,6 +2388,7 @@ const deserializeAws_json1_1MLModels = (output, context) => {
2992
2388
  }
2993
2389
  return deserializeAws_json1_1MLModel(entry, context);
2994
2390
  });
2391
+ return retVal;
2995
2392
  };
2996
2393
  const deserializeAws_json1_1PerformanceMetrics = (output, context) => {
2997
2394
  return {
@@ -3107,7 +2504,7 @@ const deserializeAws_json1_1TagLimitExceededException = (output, context) => {
3107
2504
  };
3108
2505
  };
3109
2506
  const deserializeAws_json1_1TagList = (output, context) => {
3110
- return (output || [])
2507
+ const retVal = (output || [])
3111
2508
  .filter((e) => e != null)
3112
2509
  .map((entry) => {
3113
2510
  if (entry === null) {
@@ -3115,6 +2512,7 @@ const deserializeAws_json1_1TagList = (output, context) => {
3115
2512
  }
3116
2513
  return deserializeAws_json1_1Tag(entry, context);
3117
2514
  });
2515
+ return retVal;
3118
2516
  };
3119
2517
  const deserializeAws_json1_1TrainingParameters = (output, context) => {
3120
2518
  return Object.entries(output).reduce((acc, [key, value]) => {