@aws-sdk/client-appstream 3.504.0 → 3.509.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 (3) hide show
  1. package/dist-cjs/index.js +161 -2116
  2. package/dist-es/protocols/Aws_json1_1.js +198 -2153
  3. package/package.json +3 -3
package/dist-es/protocols/Aws_json1_1.js CHANGED
@@ -454,7 +454,7 @@ export const se_UpdateStackCommand = async (input, context) => {
454
454
  };
455
455
  export const de_AssociateAppBlockBuilderAppBlockCommand = async (output, context) => {
456
456
  if (output.statusCode >= 300) {
457
- return de_AssociateAppBlockBuilderAppBlockCommandError(output, context);
457
+ return de_CommandError(output, context);
458
458
  }
459
459
  const data = await parseBody(output.body, context);
460
460
  let contents = {};
@@ -465,40 +465,9 @@ export const de_AssociateAppBlockBuilderAppBlockCommand = async (output, context
465
465
  };
466
466
  return response;
467
467
  };
468
- const de_AssociateAppBlockBuilderAppBlockCommandError = async (output, context) => {
469
- const parsedOutput = {
470
- ...output,
471
- body: await parseErrorBody(output.body, context),
472
- };
473
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
474
- switch (errorCode) {
475
- case "ConcurrentModificationException":
476
- case "com.amazonaws.appstream#ConcurrentModificationException":
477
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
478
- case "InvalidParameterCombinationException":
479
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
480
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
481
- case "LimitExceededException":
482
- case "com.amazonaws.appstream#LimitExceededException":
483
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
484
- case "OperationNotPermittedException":
485
- case "com.amazonaws.appstream#OperationNotPermittedException":
486
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
487
- case "ResourceNotFoundException":
488
- case "com.amazonaws.appstream#ResourceNotFoundException":
489
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
490
- default:
491
- const parsedBody = parsedOutput.body;
492
- return throwDefaultError({
493
- output,
494
- parsedBody,
495
- errorCode,
496
- });
497
- }
498
- };
499
468
  export const de_AssociateApplicationFleetCommand = async (output, context) => {
500
469
  if (output.statusCode >= 300) {
501
- return de_AssociateApplicationFleetCommandError(output, context);
470
+ return de_CommandError(output, context);
502
471
  }
503
472
  const data = await parseBody(output.body, context);
504
473
  let contents = {};
@@ -509,40 +478,9 @@ export const de_AssociateApplicationFleetCommand = async (output, context) => {
509
478
  };
510
479
  return response;
511
480
  };
512
- const de_AssociateApplicationFleetCommandError = async (output, context) => {
513
- const parsedOutput = {
514
- ...output,
515
- body: await parseErrorBody(output.body, context),
516
- };
517
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
518
- switch (errorCode) {
519
- case "ConcurrentModificationException":
520
- case "com.amazonaws.appstream#ConcurrentModificationException":
521
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
522
- case "InvalidParameterCombinationException":
523
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
524
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
525
- case "LimitExceededException":
526
- case "com.amazonaws.appstream#LimitExceededException":
527
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
528
- case "OperationNotPermittedException":
529
- case "com.amazonaws.appstream#OperationNotPermittedException":
530
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
531
- case "ResourceNotFoundException":
532
- case "com.amazonaws.appstream#ResourceNotFoundException":
533
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
534
- default:
535
- const parsedBody = parsedOutput.body;
536
- return throwDefaultError({
537
- output,
538
- parsedBody,
539
- errorCode,
540
- });
541
- }
542
- };
543
481
  export const de_AssociateApplicationToEntitlementCommand = async (output, context) => {
544
482
  if (output.statusCode >= 300) {
545
- return de_AssociateApplicationToEntitlementCommandError(output, context);
483
+ return de_CommandError(output, context);
546
484
  }
547
485
  const data = await parseBody(output.body, context);
548
486
  let contents = {};
@@ -553,37 +491,9 @@ export const de_AssociateApplicationToEntitlementCommand = async (output, contex
553
491
  };
554
492
  return response;
555
493
  };
556
- const de_AssociateApplicationToEntitlementCommandError = async (output, context) => {
557
- const parsedOutput = {
558
- ...output,
559
- body: await parseErrorBody(output.body, context),
560
- };
561
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
562
- switch (errorCode) {
563
- case "EntitlementNotFoundException":
564
- case "com.amazonaws.appstream#EntitlementNotFoundException":
565
- throw await de_EntitlementNotFoundExceptionRes(parsedOutput, context);
566
- case "LimitExceededException":
567
- case "com.amazonaws.appstream#LimitExceededException":
568
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
569
- case "OperationNotPermittedException":
570
- case "com.amazonaws.appstream#OperationNotPermittedException":
571
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
572
- case "ResourceNotFoundException":
573
- case "com.amazonaws.appstream#ResourceNotFoundException":
574
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
575
- default:
576
- const parsedBody = parsedOutput.body;
577
- return throwDefaultError({
578
- output,
579
- parsedBody,
580
- errorCode,
581
- });
582
- }
583
- };
584
494
  export const de_AssociateFleetCommand = async (output, context) => {
585
495
  if (output.statusCode >= 300) {
586
- return de_AssociateFleetCommandError(output, context);
496
+ return de_CommandError(output, context);
587
497
  }
588
498
  const data = await parseBody(output.body, context);
589
499
  let contents = {};
@@ -594,43 +504,9 @@ export const de_AssociateFleetCommand = async (output, context) => {
594
504
  };
595
505
  return response;
596
506
  };
597
- const de_AssociateFleetCommandError = async (output, context) => {
598
- const parsedOutput = {
599
- ...output,
600
- body: await parseErrorBody(output.body, context),
601
- };
602
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
603
- switch (errorCode) {
604
- case "ConcurrentModificationException":
605
- case "com.amazonaws.appstream#ConcurrentModificationException":
606
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
607
- case "IncompatibleImageException":
608
- case "com.amazonaws.appstream#IncompatibleImageException":
609
- throw await de_IncompatibleImageExceptionRes(parsedOutput, context);
610
- case "InvalidAccountStatusException":
611
- case "com.amazonaws.appstream#InvalidAccountStatusException":
612
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
613
- case "LimitExceededException":
614
- case "com.amazonaws.appstream#LimitExceededException":
615
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
616
- case "OperationNotPermittedException":
617
- case "com.amazonaws.appstream#OperationNotPermittedException":
618
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
619
- case "ResourceNotFoundException":
620
- case "com.amazonaws.appstream#ResourceNotFoundException":
621
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
622
- default:
623
- const parsedBody = parsedOutput.body;
624
- return throwDefaultError({
625
- output,
626
- parsedBody,
627
- errorCode,
628
- });
629
- }
630
- };
631
507
  export const de_BatchAssociateUserStackCommand = async (output, context) => {
632
508
  if (output.statusCode >= 300) {
633
- return de_BatchAssociateUserStackCommandError(output, context);
509
+ return de_CommandError(output, context);
634
510
  }
635
511
  const data = await parseBody(output.body, context);
636
512
  let contents = {};
@@ -641,31 +517,9 @@ export const de_BatchAssociateUserStackCommand = async (output, context) => {
641
517
  };
642
518
  return response;
643
519
  };
644
- const de_BatchAssociateUserStackCommandError = async (output, context) => {
645
- const parsedOutput = {
646
- ...output,
647
- body: await parseErrorBody(output.body, context),
648
- };
649
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
650
- switch (errorCode) {
651
- case "InvalidParameterCombinationException":
652
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
653
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
654
- case "OperationNotPermittedException":
655
- case "com.amazonaws.appstream#OperationNotPermittedException":
656
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
657
- default:
658
- const parsedBody = parsedOutput.body;
659
- return throwDefaultError({
660
- output,
661
- parsedBody,
662
- errorCode,
663
- });
664
- }
665
- };
666
520
  export const de_BatchDisassociateUserStackCommand = async (output, context) => {
667
521
  if (output.statusCode >= 300) {
668
- return de_BatchDisassociateUserStackCommandError(output, context);
522
+ return de_CommandError(output, context);
669
523
  }
670
524
  const data = await parseBody(output.body, context);
671
525
  let contents = {};
@@ -676,31 +530,9 @@ export const de_BatchDisassociateUserStackCommand = async (output, context) => {
676
530
  };
677
531
  return response;
678
532
  };
679
- const de_BatchDisassociateUserStackCommandError = async (output, context) => {
680
- const parsedOutput = {
681
- ...output,
682
- body: await parseErrorBody(output.body, context),
683
- };
684
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
685
- switch (errorCode) {
686
- case "InvalidParameterCombinationException":
687
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
688
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
689
- case "OperationNotPermittedException":
690
- case "com.amazonaws.appstream#OperationNotPermittedException":
691
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
692
- default:
693
- const parsedBody = parsedOutput.body;
694
- return throwDefaultError({
695
- output,
696
- parsedBody,
697
- errorCode,
698
- });
699
- }
700
- };
701
533
  export const de_CopyImageCommand = async (output, context) => {
702
534
  if (output.statusCode >= 300) {
703
- return de_CopyImageCommandError(output, context);
535
+ return de_CommandError(output, context);
704
536
  }
705
537
  const data = await parseBody(output.body, context);
706
538
  let contents = {};
@@ -711,43 +543,9 @@ export const de_CopyImageCommand = async (output, context) => {
711
543
  };
712
544
  return response;
713
545
  };
714
- const de_CopyImageCommandError = async (output, context) => {
715
- const parsedOutput = {
716
- ...output,
717
- body: await parseErrorBody(output.body, context),
718
- };
719
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
720
- switch (errorCode) {
721
- case "IncompatibleImageException":
722
- case "com.amazonaws.appstream#IncompatibleImageException":
723
- throw await de_IncompatibleImageExceptionRes(parsedOutput, context);
724
- case "InvalidAccountStatusException":
725
- case "com.amazonaws.appstream#InvalidAccountStatusException":
726
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
727
- case "LimitExceededException":
728
- case "com.amazonaws.appstream#LimitExceededException":
729
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
730
- case "ResourceAlreadyExistsException":
731
- case "com.amazonaws.appstream#ResourceAlreadyExistsException":
732
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
733
- case "ResourceNotAvailableException":
734
- case "com.amazonaws.appstream#ResourceNotAvailableException":
735
- throw await de_ResourceNotAvailableExceptionRes(parsedOutput, context);
736
- case "ResourceNotFoundException":
737
- case "com.amazonaws.appstream#ResourceNotFoundException":
738
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
739
- default:
740
- const parsedBody = parsedOutput.body;
741
- return throwDefaultError({
742
- output,
743
- parsedBody,
744
- errorCode,
745
- });
746
- }
747
- };
748
546
  export const de_CreateAppBlockCommand = async (output, context) => {
749
547
  if (output.statusCode >= 300) {
750
- return de_CreateAppBlockCommandError(output, context);
548
+ return de_CommandError(output, context);
751
549
  }
752
550
  const data = await parseBody(output.body, context);
753
551
  let contents = {};
@@ -758,222 +556,61 @@ export const de_CreateAppBlockCommand = async (output, context) => {
758
556
  };
759
557
  return response;
760
558
  };
761
- const de_CreateAppBlockCommandError = async (output, context) => {
762
- const parsedOutput = {
763
- ...output,
764
- body: await parseErrorBody(output.body, context),
559
+ export const de_CreateAppBlockBuilderCommand = async (output, context) => {
560
+ if (output.statusCode >= 300) {
561
+ return de_CommandError(output, context);
562
+ }
563
+ const data = await parseBody(output.body, context);
564
+ let contents = {};
565
+ contents = de_CreateAppBlockBuilderResult(data, context);
566
+ const response = {
567
+ $metadata: deserializeMetadata(output),
568
+ ...contents,
765
569
  };
766
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
767
- switch (errorCode) {
768
- case "ConcurrentModificationException":
769
- case "com.amazonaws.appstream#ConcurrentModificationException":
770
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
771
- case "LimitExceededException":
772
- case "com.amazonaws.appstream#LimitExceededException":
773
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
774
- case "OperationNotPermittedException":
775
- case "com.amazonaws.appstream#OperationNotPermittedException":
776
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
777
- case "ResourceAlreadyExistsException":
778
- case "com.amazonaws.appstream#ResourceAlreadyExistsException":
779
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
780
- default:
781
- const parsedBody = parsedOutput.body;
782
- return throwDefaultError({
783
- output,
784
- parsedBody,
785
- errorCode,
786
- });
570
+ return response;
571
+ };
572
+ export const de_CreateAppBlockBuilderStreamingURLCommand = async (output, context) => {
573
+ if (output.statusCode >= 300) {
574
+ return de_CommandError(output, context);
787
575
  }
576
+ const data = await parseBody(output.body, context);
577
+ let contents = {};
578
+ contents = de_CreateAppBlockBuilderStreamingURLResult(data, context);
579
+ const response = {
580
+ $metadata: deserializeMetadata(output),
581
+ ...contents,
582
+ };
583
+ return response;
788
584
  };
789
- export const de_CreateAppBlockBuilderCommand = async (output, context) => {
585
+ export const de_CreateApplicationCommand = async (output, context) => {
790
586
  if (output.statusCode >= 300) {
791
- return de_CreateAppBlockBuilderCommandError(output, context);
587
+ return de_CommandError(output, context);
792
588
  }
793
589
  const data = await parseBody(output.body, context);
794
590
  let contents = {};
795
- contents = de_CreateAppBlockBuilderResult(data, context);
591
+ contents = de_CreateApplicationResult(data, context);
796
592
  const response = {
797
593
  $metadata: deserializeMetadata(output),
798
594
  ...contents,
799
595
  };
800
596
  return response;
801
597
  };
802
- const de_CreateAppBlockBuilderCommandError = async (output, context) => {
803
- const parsedOutput = {
804
- ...output,
805
- body: await parseErrorBody(output.body, context),
806
- };
807
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
808
- switch (errorCode) {
809
- case "ConcurrentModificationException":
810
- case "com.amazonaws.appstream#ConcurrentModificationException":
811
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
812
- case "InvalidAccountStatusException":
813
- case "com.amazonaws.appstream#InvalidAccountStatusException":
814
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
815
- case "InvalidParameterCombinationException":
816
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
817
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
818
- case "InvalidRoleException":
819
- case "com.amazonaws.appstream#InvalidRoleException":
820
- throw await de_InvalidRoleExceptionRes(parsedOutput, context);
821
- case "LimitExceededException":
822
- case "com.amazonaws.appstream#LimitExceededException":
823
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
824
- case "OperationNotPermittedException":
825
- case "com.amazonaws.appstream#OperationNotPermittedException":
826
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
827
- case "RequestLimitExceededException":
828
- case "com.amazonaws.appstream#RequestLimitExceededException":
829
- throw await de_RequestLimitExceededExceptionRes(parsedOutput, context);
830
- case "ResourceAlreadyExistsException":
831
- case "com.amazonaws.appstream#ResourceAlreadyExistsException":
832
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
833
- case "ResourceNotAvailableException":
834
- case "com.amazonaws.appstream#ResourceNotAvailableException":
835
- throw await de_ResourceNotAvailableExceptionRes(parsedOutput, context);
836
- case "ResourceNotFoundException":
837
- case "com.amazonaws.appstream#ResourceNotFoundException":
838
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
839
- default:
840
- const parsedBody = parsedOutput.body;
841
- return throwDefaultError({
842
- output,
843
- parsedBody,
844
- errorCode,
845
- });
846
- }
847
- };
848
- export const de_CreateAppBlockBuilderStreamingURLCommand = async (output, context) => {
849
- if (output.statusCode >= 300) {
850
- return de_CreateAppBlockBuilderStreamingURLCommandError(output, context);
851
- }
852
- const data = await parseBody(output.body, context);
853
- let contents = {};
854
- contents = de_CreateAppBlockBuilderStreamingURLResult(data, context);
855
- const response = {
856
- $metadata: deserializeMetadata(output),
857
- ...contents,
598
+ export const de_CreateDirectoryConfigCommand = async (output, context) => {
599
+ if (output.statusCode >= 300) {
600
+ return de_CommandError(output, context);
601
+ }
602
+ const data = await parseBody(output.body, context);
603
+ let contents = {};
604
+ contents = de_CreateDirectoryConfigResult(data, context);
605
+ const response = {
606
+ $metadata: deserializeMetadata(output),
607
+ ...contents,
858
608
  };
859
609
  return response;
860
610
  };
861
- const de_CreateAppBlockBuilderStreamingURLCommandError = async (output, context) => {
862
- const parsedOutput = {
863
- ...output,
864
- body: await parseErrorBody(output.body, context),
865
- };
866
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
867
- switch (errorCode) {
868
- case "OperationNotPermittedException":
869
- case "com.amazonaws.appstream#OperationNotPermittedException":
870
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
871
- case "ResourceNotFoundException":
872
- case "com.amazonaws.appstream#ResourceNotFoundException":
873
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
874
- default:
875
- const parsedBody = parsedOutput.body;
876
- return throwDefaultError({
877
- output,
878
- parsedBody,
879
- errorCode,
880
- });
881
- }
882
- };
883
- export const de_CreateApplicationCommand = async (output, context) => {
884
- if (output.statusCode >= 300) {
885
- return de_CreateApplicationCommandError(output, context);
886
- }
887
- const data = await parseBody(output.body, context);
888
- let contents = {};
889
- contents = de_CreateApplicationResult(data, context);
890
- const response = {
891
- $metadata: deserializeMetadata(output),
892
- ...contents,
893
- };
894
- return response;
895
- };
896
- const de_CreateApplicationCommandError = async (output, context) => {
897
- const parsedOutput = {
898
- ...output,
899
- body: await parseErrorBody(output.body, context),
900
- };
901
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
902
- switch (errorCode) {
903
- case "ConcurrentModificationException":
904
- case "com.amazonaws.appstream#ConcurrentModificationException":
905
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
906
- case "LimitExceededException":
907
- case "com.amazonaws.appstream#LimitExceededException":
908
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
909
- case "OperationNotPermittedException":
910
- case "com.amazonaws.appstream#OperationNotPermittedException":
911
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
912
- case "ResourceAlreadyExistsException":
913
- case "com.amazonaws.appstream#ResourceAlreadyExistsException":
914
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
915
- case "ResourceNotFoundException":
916
- case "com.amazonaws.appstream#ResourceNotFoundException":
917
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
918
- default:
919
- const parsedBody = parsedOutput.body;
920
- return throwDefaultError({
921
- output,
922
- parsedBody,
923
- errorCode,
924
- });
925
- }
926
- };
927
- export const de_CreateDirectoryConfigCommand = async (output, context) => {
928
- if (output.statusCode >= 300) {
929
- return de_CreateDirectoryConfigCommandError(output, context);
930
- }
931
- const data = await parseBody(output.body, context);
932
- let contents = {};
933
- contents = de_CreateDirectoryConfigResult(data, context);
934
- const response = {
935
- $metadata: deserializeMetadata(output),
936
- ...contents,
937
- };
938
- return response;
939
- };
940
- const de_CreateDirectoryConfigCommandError = async (output, context) => {
941
- const parsedOutput = {
942
- ...output,
943
- body: await parseErrorBody(output.body, context),
944
- };
945
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
946
- switch (errorCode) {
947
- case "InvalidAccountStatusException":
948
- case "com.amazonaws.appstream#InvalidAccountStatusException":
949
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
950
- case "InvalidRoleException":
951
- case "com.amazonaws.appstream#InvalidRoleException":
952
- throw await de_InvalidRoleExceptionRes(parsedOutput, context);
953
- case "LimitExceededException":
954
- case "com.amazonaws.appstream#LimitExceededException":
955
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
956
- case "OperationNotPermittedException":
957
- case "com.amazonaws.appstream#OperationNotPermittedException":
958
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
959
- case "ResourceAlreadyExistsException":
960
- case "com.amazonaws.appstream#ResourceAlreadyExistsException":
961
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
962
- case "ResourceNotFoundException":
963
- case "com.amazonaws.appstream#ResourceNotFoundException":
964
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
965
- default:
966
- const parsedBody = parsedOutput.body;
967
- return throwDefaultError({
968
- output,
969
- parsedBody,
970
- errorCode,
971
- });
972
- }
973
- };
974
611
  export const de_CreateEntitlementCommand = async (output, context) => {
975
612
  if (output.statusCode >= 300) {
976
- return de_CreateEntitlementCommandError(output, context);
613
+ return de_CommandError(output, context);
977
614
  }
978
615
  const data = await parseBody(output.body, context);
979
616
  let contents = {};
@@ -984,460 +621,87 @@ export const de_CreateEntitlementCommand = async (output, context) => {
984
621
  };
985
622
  return response;
986
623
  };
987
- const de_CreateEntitlementCommandError = async (output, context) => {
988
- const parsedOutput = {
989
- ...output,
990
- body: await parseErrorBody(output.body, context),
991
- };
992
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
993
- switch (errorCode) {
994
- case "EntitlementAlreadyExistsException":
995
- case "com.amazonaws.appstream#EntitlementAlreadyExistsException":
996
- throw await de_EntitlementAlreadyExistsExceptionRes(parsedOutput, context);
997
- case "LimitExceededException":
998
- case "com.amazonaws.appstream#LimitExceededException":
999
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1000
- case "OperationNotPermittedException":
1001
- case "com.amazonaws.appstream#OperationNotPermittedException":
1002
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
1003
- case "ResourceNotFoundException":
1004
- case "com.amazonaws.appstream#ResourceNotFoundException":
1005
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1006
- default:
1007
- const parsedBody = parsedOutput.body;
1008
- return throwDefaultError({
1009
- output,
1010
- parsedBody,
1011
- errorCode,
1012
- });
1013
- }
1014
- };
1015
- export const de_CreateFleetCommand = async (output, context) => {
1016
- if (output.statusCode >= 300) {
1017
- return de_CreateFleetCommandError(output, context);
1018
- }
1019
- const data = await parseBody(output.body, context);
1020
- let contents = {};
1021
- contents = de_CreateFleetResult(data, context);
1022
- const response = {
1023
- $metadata: deserializeMetadata(output),
1024
- ...contents,
1025
- };
1026
- return response;
1027
- };
1028
- const de_CreateFleetCommandError = async (output, context) => {
1029
- const parsedOutput = {
1030
- ...output,
1031
- body: await parseErrorBody(output.body, context),
1032
- };
1033
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1034
- switch (errorCode) {
1035
- case "ConcurrentModificationException":
1036
- case "com.amazonaws.appstream#ConcurrentModificationException":
1037
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1038
- case "IncompatibleImageException":
1039
- case "com.amazonaws.appstream#IncompatibleImageException":
1040
- throw await de_IncompatibleImageExceptionRes(parsedOutput, context);
1041
- case "InvalidAccountStatusException":
1042
- case "com.amazonaws.appstream#InvalidAccountStatusException":
1043
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
1044
- case "InvalidParameterCombinationException":
1045
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
1046
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
1047
- case "InvalidRoleException":
1048
- case "com.amazonaws.appstream#InvalidRoleException":
1049
- throw await de_InvalidRoleExceptionRes(parsedOutput, context);
1050
- case "LimitExceededException":
1051
- case "com.amazonaws.appstream#LimitExceededException":
1052
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1053
- case "OperationNotPermittedException":
1054
- case "com.amazonaws.appstream#OperationNotPermittedException":
1055
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
1056
- case "RequestLimitExceededException":
1057
- case "com.amazonaws.appstream#RequestLimitExceededException":
1058
- throw await de_RequestLimitExceededExceptionRes(parsedOutput, context);
1059
- case "ResourceAlreadyExistsException":
1060
- case "com.amazonaws.appstream#ResourceAlreadyExistsException":
1061
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
1062
- case "ResourceNotAvailableException":
1063
- case "com.amazonaws.appstream#ResourceNotAvailableException":
1064
- throw await de_ResourceNotAvailableExceptionRes(parsedOutput, context);
1065
- case "ResourceNotFoundException":
1066
- case "com.amazonaws.appstream#ResourceNotFoundException":
1067
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1068
- default:
1069
- const parsedBody = parsedOutput.body;
1070
- return throwDefaultError({
1071
- output,
1072
- parsedBody,
1073
- errorCode,
1074
- });
1075
- }
1076
- };
1077
- export const de_CreateImageBuilderCommand = async (output, context) => {
1078
- if (output.statusCode >= 300) {
1079
- return de_CreateImageBuilderCommandError(output, context);
1080
- }
1081
- const data = await parseBody(output.body, context);
1082
- let contents = {};
1083
- contents = de_CreateImageBuilderResult(data, context);
1084
- const response = {
1085
- $metadata: deserializeMetadata(output),
1086
- ...contents,
1087
- };
1088
- return response;
1089
- };
1090
- const de_CreateImageBuilderCommandError = async (output, context) => {
1091
- const parsedOutput = {
1092
- ...output,
1093
- body: await parseErrorBody(output.body, context),
1094
- };
1095
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1096
- switch (errorCode) {
1097
- case "ConcurrentModificationException":
1098
- case "com.amazonaws.appstream#ConcurrentModificationException":
1099
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1100
- case "IncompatibleImageException":
1101
- case "com.amazonaws.appstream#IncompatibleImageException":
1102
- throw await de_IncompatibleImageExceptionRes(parsedOutput, context);
1103
- case "InvalidAccountStatusException":
1104
- case "com.amazonaws.appstream#InvalidAccountStatusException":
1105
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
1106
- case "InvalidParameterCombinationException":
1107
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
1108
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
1109
- case "InvalidRoleException":
1110
- case "com.amazonaws.appstream#InvalidRoleException":
1111
- throw await de_InvalidRoleExceptionRes(parsedOutput, context);
1112
- case "LimitExceededException":
1113
- case "com.amazonaws.appstream#LimitExceededException":
1114
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1115
- case "OperationNotPermittedException":
1116
- case "com.amazonaws.appstream#OperationNotPermittedException":
1117
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
1118
- case "RequestLimitExceededException":
1119
- case "com.amazonaws.appstream#RequestLimitExceededException":
1120
- throw await de_RequestLimitExceededExceptionRes(parsedOutput, context);
1121
- case "ResourceAlreadyExistsException":
1122
- case "com.amazonaws.appstream#ResourceAlreadyExistsException":
1123
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
1124
- case "ResourceNotAvailableException":
1125
- case "com.amazonaws.appstream#ResourceNotAvailableException":
1126
- throw await de_ResourceNotAvailableExceptionRes(parsedOutput, context);
1127
- case "ResourceNotFoundException":
1128
- case "com.amazonaws.appstream#ResourceNotFoundException":
1129
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1130
- default:
1131
- const parsedBody = parsedOutput.body;
1132
- return throwDefaultError({
1133
- output,
1134
- parsedBody,
1135
- errorCode,
1136
- });
1137
- }
1138
- };
1139
- export const de_CreateImageBuilderStreamingURLCommand = async (output, context) => {
1140
- if (output.statusCode >= 300) {
1141
- return de_CreateImageBuilderStreamingURLCommandError(output, context);
1142
- }
1143
- const data = await parseBody(output.body, context);
1144
- let contents = {};
1145
- contents = de_CreateImageBuilderStreamingURLResult(data, context);
1146
- const response = {
1147
- $metadata: deserializeMetadata(output),
1148
- ...contents,
1149
- };
1150
- return response;
1151
- };
1152
- const de_CreateImageBuilderStreamingURLCommandError = async (output, context) => {
1153
- const parsedOutput = {
1154
- ...output,
1155
- body: await parseErrorBody(output.body, context),
1156
- };
1157
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1158
- switch (errorCode) {
1159
- case "OperationNotPermittedException":
1160
- case "com.amazonaws.appstream#OperationNotPermittedException":
1161
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
1162
- case "ResourceNotFoundException":
1163
- case "com.amazonaws.appstream#ResourceNotFoundException":
1164
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1165
- default:
1166
- const parsedBody = parsedOutput.body;
1167
- return throwDefaultError({
1168
- output,
1169
- parsedBody,
1170
- errorCode,
1171
- });
1172
- }
1173
- };
1174
- export const de_CreateStackCommand = async (output, context) => {
624
+ export const de_CreateFleetCommand = async (output, context) => {
1175
625
  if (output.statusCode >= 300) {
1176
- return de_CreateStackCommandError(output, context);
626
+ return de_CommandError(output, context);
1177
627
  }
1178
628
  const data = await parseBody(output.body, context);
1179
629
  let contents = {};
1180
- contents = de_CreateStackResult(data, context);
630
+ contents = de_CreateFleetResult(data, context);
1181
631
  const response = {
1182
632
  $metadata: deserializeMetadata(output),
1183
633
  ...contents,
1184
634
  };
1185
635
  return response;
1186
636
  };
1187
- const de_CreateStackCommandError = async (output, context) => {
1188
- const parsedOutput = {
1189
- ...output,
1190
- body: await parseErrorBody(output.body, context),
1191
- };
1192
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1193
- switch (errorCode) {
1194
- case "ConcurrentModificationException":
1195
- case "com.amazonaws.appstream#ConcurrentModificationException":
1196
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1197
- case "InvalidAccountStatusException":
1198
- case "com.amazonaws.appstream#InvalidAccountStatusException":
1199
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
1200
- case "InvalidParameterCombinationException":
1201
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
1202
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
1203
- case "InvalidRoleException":
1204
- case "com.amazonaws.appstream#InvalidRoleException":
1205
- throw await de_InvalidRoleExceptionRes(parsedOutput, context);
1206
- case "LimitExceededException":
1207
- case "com.amazonaws.appstream#LimitExceededException":
1208
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1209
- case "OperationNotPermittedException":
1210
- case "com.amazonaws.appstream#OperationNotPermittedException":
1211
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
1212
- case "ResourceAlreadyExistsException":
1213
- case "com.amazonaws.appstream#ResourceAlreadyExistsException":
1214
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
1215
- case "ResourceNotFoundException":
1216
- case "com.amazonaws.appstream#ResourceNotFoundException":
1217
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1218
- default:
1219
- const parsedBody = parsedOutput.body;
1220
- return throwDefaultError({
1221
- output,
1222
- parsedBody,
1223
- errorCode,
1224
- });
1225
- }
1226
- };
1227
- export const de_CreateStreamingURLCommand = async (output, context) => {
637
+ export const de_CreateImageBuilderCommand = async (output, context) => {
1228
638
  if (output.statusCode >= 300) {
1229
- return de_CreateStreamingURLCommandError(output, context);
639
+ return de_CommandError(output, context);
1230
640
  }
1231
641
  const data = await parseBody(output.body, context);
1232
642
  let contents = {};
1233
- contents = de_CreateStreamingURLResult(data, context);
643
+ contents = de_CreateImageBuilderResult(data, context);
1234
644
  const response = {
1235
645
  $metadata: deserializeMetadata(output),
1236
646
  ...contents,
1237
647
  };
1238
648
  return response;
1239
649
  };
1240
- const de_CreateStreamingURLCommandError = async (output, context) => {
1241
- const parsedOutput = {
1242
- ...output,
1243
- body: await parseErrorBody(output.body, context),
1244
- };
1245
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1246
- switch (errorCode) {
1247
- case "InvalidParameterCombinationException":
1248
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
1249
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
1250
- case "OperationNotPermittedException":
1251
- case "com.amazonaws.appstream#OperationNotPermittedException":
1252
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
1253
- case "ResourceNotAvailableException":
1254
- case "com.amazonaws.appstream#ResourceNotAvailableException":
1255
- throw await de_ResourceNotAvailableExceptionRes(parsedOutput, context);
1256
- case "ResourceNotFoundException":
1257
- case "com.amazonaws.appstream#ResourceNotFoundException":
1258
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1259
- default:
1260
- const parsedBody = parsedOutput.body;
1261
- return throwDefaultError({
1262
- output,
1263
- parsedBody,
1264
- errorCode,
1265
- });
1266
- }
1267
- };
1268
- export const de_CreateUpdatedImageCommand = async (output, context) => {
650
+ export const de_CreateImageBuilderStreamingURLCommand = async (output, context) => {
1269
651
  if (output.statusCode >= 300) {
1270
- return de_CreateUpdatedImageCommandError(output, context);
652
+ return de_CommandError(output, context);
1271
653
  }
1272
654
  const data = await parseBody(output.body, context);
1273
655
  let contents = {};
1274
- contents = de_CreateUpdatedImageResult(data, context);
656
+ contents = de_CreateImageBuilderStreamingURLResult(data, context);
1275
657
  const response = {
1276
658
  $metadata: deserializeMetadata(output),
1277
659
  ...contents,
1278
660
  };
1279
661
  return response;
1280
662
  };
1281
- const de_CreateUpdatedImageCommandError = async (output, context) => {
1282
- const parsedOutput = {
1283
- ...output,
1284
- body: await parseErrorBody(output.body, context),
1285
- };
1286
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1287
- switch (errorCode) {
1288
- case "ConcurrentModificationException":
1289
- case "com.amazonaws.appstream#ConcurrentModificationException":
1290
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1291
- case "IncompatibleImageException":
1292
- case "com.amazonaws.appstream#IncompatibleImageException":
1293
- throw await de_IncompatibleImageExceptionRes(parsedOutput, context);
1294
- case "InvalidAccountStatusException":
1295
- case "com.amazonaws.appstream#InvalidAccountStatusException":
1296
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
1297
- case "LimitExceededException":
1298
- case "com.amazonaws.appstream#LimitExceededException":
1299
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1300
- case "OperationNotPermittedException":
1301
- case "com.amazonaws.appstream#OperationNotPermittedException":
1302
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
1303
- case "ResourceAlreadyExistsException":
1304
- case "com.amazonaws.appstream#ResourceAlreadyExistsException":
1305
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
1306
- case "ResourceNotFoundException":
1307
- case "com.amazonaws.appstream#ResourceNotFoundException":
1308
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1309
- default:
1310
- const parsedBody = parsedOutput.body;
1311
- return throwDefaultError({
1312
- output,
1313
- parsedBody,
1314
- errorCode,
1315
- });
1316
- }
1317
- };
1318
- export const de_CreateUsageReportSubscriptionCommand = async (output, context) => {
663
+ export const de_CreateStackCommand = async (output, context) => {
1319
664
  if (output.statusCode >= 300) {
1320
- return de_CreateUsageReportSubscriptionCommandError(output, context);
665
+ return de_CommandError(output, context);
1321
666
  }
1322
667
  const data = await parseBody(output.body, context);
1323
668
  let contents = {};
1324
- contents = _json(data);
669
+ contents = de_CreateStackResult(data, context);
1325
670
  const response = {
1326
671
  $metadata: deserializeMetadata(output),
1327
672
  ...contents,
1328
673
  };
1329
674
  return response;
1330
675
  };
1331
- const de_CreateUsageReportSubscriptionCommandError = async (output, context) => {
1332
- const parsedOutput = {
1333
- ...output,
1334
- body: await parseErrorBody(output.body, context),
1335
- };
1336
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1337
- switch (errorCode) {
1338
- case "InvalidAccountStatusException":
1339
- case "com.amazonaws.appstream#InvalidAccountStatusException":
1340
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
1341
- case "InvalidRoleException":
1342
- case "com.amazonaws.appstream#InvalidRoleException":
1343
- throw await de_InvalidRoleExceptionRes(parsedOutput, context);
1344
- case "LimitExceededException":
1345
- case "com.amazonaws.appstream#LimitExceededException":
1346
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1347
- default:
1348
- const parsedBody = parsedOutput.body;
1349
- return throwDefaultError({
1350
- output,
1351
- parsedBody,
1352
- errorCode,
1353
- });
1354
- }
1355
- };
1356
- export const de_CreateUserCommand = async (output, context) => {
676
+ export const de_CreateStreamingURLCommand = async (output, context) => {
1357
677
  if (output.statusCode >= 300) {
1358
- return de_CreateUserCommandError(output, context);
678
+ return de_CommandError(output, context);
1359
679
  }
1360
680
  const data = await parseBody(output.body, context);
1361
681
  let contents = {};
1362
- contents = _json(data);
682
+ contents = de_CreateStreamingURLResult(data, context);
1363
683
  const response = {
1364
684
  $metadata: deserializeMetadata(output),
1365
685
  ...contents,
1366
686
  };
1367
687
  return response;
1368
688
  };
1369
- const de_CreateUserCommandError = async (output, context) => {
1370
- const parsedOutput = {
1371
- ...output,
1372
- body: await parseErrorBody(output.body, context),
1373
- };
1374
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1375
- switch (errorCode) {
1376
- case "InvalidAccountStatusException":
1377
- case "com.amazonaws.appstream#InvalidAccountStatusException":
1378
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
1379
- case "InvalidParameterCombinationException":
1380
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
1381
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
1382
- case "LimitExceededException":
1383
- case "com.amazonaws.appstream#LimitExceededException":
1384
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1385
- case "OperationNotPermittedException":
1386
- case "com.amazonaws.appstream#OperationNotPermittedException":
1387
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
1388
- case "ResourceAlreadyExistsException":
1389
- case "com.amazonaws.appstream#ResourceAlreadyExistsException":
1390
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
1391
- default:
1392
- const parsedBody = parsedOutput.body;
1393
- return throwDefaultError({
1394
- output,
1395
- parsedBody,
1396
- errorCode,
1397
- });
1398
- }
1399
- };
1400
- export const de_DeleteAppBlockCommand = async (output, context) => {
689
+ export const de_CreateUpdatedImageCommand = async (output, context) => {
1401
690
  if (output.statusCode >= 300) {
1402
- return de_DeleteAppBlockCommandError(output, context);
691
+ return de_CommandError(output, context);
1403
692
  }
1404
693
  const data = await parseBody(output.body, context);
1405
694
  let contents = {};
1406
- contents = _json(data);
695
+ contents = de_CreateUpdatedImageResult(data, context);
1407
696
  const response = {
1408
697
  $metadata: deserializeMetadata(output),
1409
698
  ...contents,
1410
699
  };
1411
700
  return response;
1412
701
  };
1413
- const de_DeleteAppBlockCommandError = async (output, context) => {
1414
- const parsedOutput = {
1415
- ...output,
1416
- body: await parseErrorBody(output.body, context),
1417
- };
1418
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1419
- switch (errorCode) {
1420
- case "ConcurrentModificationException":
1421
- case "com.amazonaws.appstream#ConcurrentModificationException":
1422
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1423
- case "ResourceInUseException":
1424
- case "com.amazonaws.appstream#ResourceInUseException":
1425
- throw await de_ResourceInUseExceptionRes(parsedOutput, context);
1426
- case "ResourceNotFoundException":
1427
- case "com.amazonaws.appstream#ResourceNotFoundException":
1428
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1429
- default:
1430
- const parsedBody = parsedOutput.body;
1431
- return throwDefaultError({
1432
- output,
1433
- parsedBody,
1434
- errorCode,
1435
- });
1436
- }
1437
- };
1438
- export const de_DeleteAppBlockBuilderCommand = async (output, context) => {
702
+ export const de_CreateUsageReportSubscriptionCommand = async (output, context) => {
1439
703
  if (output.statusCode >= 300) {
1440
- return de_DeleteAppBlockBuilderCommandError(output, context);
704
+ return de_CommandError(output, context);
1441
705
  }
1442
706
  const data = await parseBody(output.body, context);
1443
707
  let contents = {};
@@ -1448,37 +712,9 @@ export const de_DeleteAppBlockBuilderCommand = async (output, context) => {
1448
712
  };
1449
713
  return response;
1450
714
  };
1451
- const de_DeleteAppBlockBuilderCommandError = async (output, context) => {
1452
- const parsedOutput = {
1453
- ...output,
1454
- body: await parseErrorBody(output.body, context),
1455
- };
1456
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1457
- switch (errorCode) {
1458
- case "ConcurrentModificationException":
1459
- case "com.amazonaws.appstream#ConcurrentModificationException":
1460
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1461
- case "OperationNotPermittedException":
1462
- case "com.amazonaws.appstream#OperationNotPermittedException":
1463
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
1464
- case "ResourceInUseException":
1465
- case "com.amazonaws.appstream#ResourceInUseException":
1466
- throw await de_ResourceInUseExceptionRes(parsedOutput, context);
1467
- case "ResourceNotFoundException":
1468
- case "com.amazonaws.appstream#ResourceNotFoundException":
1469
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1470
- default:
1471
- const parsedBody = parsedOutput.body;
1472
- return throwDefaultError({
1473
- output,
1474
- parsedBody,
1475
- errorCode,
1476
- });
1477
- }
1478
- };
1479
- export const de_DeleteApplicationCommand = async (output, context) => {
715
+ export const de_CreateUserCommand = async (output, context) => {
1480
716
  if (output.statusCode >= 300) {
1481
- return de_DeleteApplicationCommandError(output, context);
717
+ return de_CommandError(output, context);
1482
718
  }
1483
719
  const data = await parseBody(output.body, context);
1484
720
  let contents = {};
@@ -1489,37 +725,9 @@ export const de_DeleteApplicationCommand = async (output, context) => {
1489
725
  };
1490
726
  return response;
1491
727
  };
1492
- const de_DeleteApplicationCommandError = async (output, context) => {
1493
- const parsedOutput = {
1494
- ...output,
1495
- body: await parseErrorBody(output.body, context),
1496
- };
1497
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1498
- switch (errorCode) {
1499
- case "ConcurrentModificationException":
1500
- case "com.amazonaws.appstream#ConcurrentModificationException":
1501
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1502
- case "OperationNotPermittedException":
1503
- case "com.amazonaws.appstream#OperationNotPermittedException":
1504
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
1505
- case "ResourceInUseException":
1506
- case "com.amazonaws.appstream#ResourceInUseException":
1507
- throw await de_ResourceInUseExceptionRes(parsedOutput, context);
1508
- case "ResourceNotFoundException":
1509
- case "com.amazonaws.appstream#ResourceNotFoundException":
1510
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1511
- default:
1512
- const parsedBody = parsedOutput.body;
1513
- return throwDefaultError({
1514
- output,
1515
- parsedBody,
1516
- errorCode,
1517
- });
1518
- }
1519
- };
1520
- export const de_DeleteDirectoryConfigCommand = async (output, context) => {
728
+ export const de_DeleteAppBlockCommand = async (output, context) => {
1521
729
  if (output.statusCode >= 300) {
1522
- return de_DeleteDirectoryConfigCommandError(output, context);
730
+ return de_CommandError(output, context);
1523
731
  }
1524
732
  const data = await parseBody(output.body, context);
1525
733
  let contents = {};
@@ -1530,31 +738,9 @@ export const de_DeleteDirectoryConfigCommand = async (output, context) => {
1530
738
  };
1531
739
  return response;
1532
740
  };
1533
- const de_DeleteDirectoryConfigCommandError = async (output, context) => {
1534
- const parsedOutput = {
1535
- ...output,
1536
- body: await parseErrorBody(output.body, context),
1537
- };
1538
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1539
- switch (errorCode) {
1540
- case "ResourceInUseException":
1541
- case "com.amazonaws.appstream#ResourceInUseException":
1542
- throw await de_ResourceInUseExceptionRes(parsedOutput, context);
1543
- case "ResourceNotFoundException":
1544
- case "com.amazonaws.appstream#ResourceNotFoundException":
1545
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1546
- default:
1547
- const parsedBody = parsedOutput.body;
1548
- return throwDefaultError({
1549
- output,
1550
- parsedBody,
1551
- errorCode,
1552
- });
1553
- }
1554
- };
1555
- export const de_DeleteEntitlementCommand = async (output, context) => {
741
+ export const de_DeleteAppBlockBuilderCommand = async (output, context) => {
1556
742
  if (output.statusCode >= 300) {
1557
- return de_DeleteEntitlementCommandError(output, context);
743
+ return de_CommandError(output, context);
1558
744
  }
1559
745
  const data = await parseBody(output.body, context);
1560
746
  let contents = {};
@@ -1565,37 +751,9 @@ export const de_DeleteEntitlementCommand = async (output, context) => {
1565
751
  };
1566
752
  return response;
1567
753
  };
1568
- const de_DeleteEntitlementCommandError = async (output, context) => {
1569
- const parsedOutput = {
1570
- ...output,
1571
- body: await parseErrorBody(output.body, context),
1572
- };
1573
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1574
- switch (errorCode) {
1575
- case "ConcurrentModificationException":
1576
- case "com.amazonaws.appstream#ConcurrentModificationException":
1577
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1578
- case "EntitlementNotFoundException":
1579
- case "com.amazonaws.appstream#EntitlementNotFoundException":
1580
- throw await de_EntitlementNotFoundExceptionRes(parsedOutput, context);
1581
- case "OperationNotPermittedException":
1582
- case "com.amazonaws.appstream#OperationNotPermittedException":
1583
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
1584
- case "ResourceNotFoundException":
1585
- case "com.amazonaws.appstream#ResourceNotFoundException":
1586
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1587
- default:
1588
- const parsedBody = parsedOutput.body;
1589
- return throwDefaultError({
1590
- output,
1591
- parsedBody,
1592
- errorCode,
1593
- });
1594
- }
1595
- };
1596
- export const de_DeleteFleetCommand = async (output, context) => {
754
+ export const de_DeleteApplicationCommand = async (output, context) => {
1597
755
  if (output.statusCode >= 300) {
1598
- return de_DeleteFleetCommandError(output, context);
756
+ return de_CommandError(output, context);
1599
757
  }
1600
758
  const data = await parseBody(output.body, context);
1601
759
  let contents = {};
@@ -1606,113 +764,35 @@ export const de_DeleteFleetCommand = async (output, context) => {
1606
764
  };
1607
765
  return response;
1608
766
  };
1609
- const de_DeleteFleetCommandError = async (output, context) => {
1610
- const parsedOutput = {
1611
- ...output,
1612
- body: await parseErrorBody(output.body, context),
1613
- };
1614
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1615
- switch (errorCode) {
1616
- case "ConcurrentModificationException":
1617
- case "com.amazonaws.appstream#ConcurrentModificationException":
1618
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1619
- case "ResourceInUseException":
1620
- case "com.amazonaws.appstream#ResourceInUseException":
1621
- throw await de_ResourceInUseExceptionRes(parsedOutput, context);
1622
- case "ResourceNotFoundException":
1623
- case "com.amazonaws.appstream#ResourceNotFoundException":
1624
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1625
- default:
1626
- const parsedBody = parsedOutput.body;
1627
- return throwDefaultError({
1628
- output,
1629
- parsedBody,
1630
- errorCode,
1631
- });
1632
- }
1633
- };
1634
- export const de_DeleteImageCommand = async (output, context) => {
767
+ export const de_DeleteDirectoryConfigCommand = async (output, context) => {
1635
768
  if (output.statusCode >= 300) {
1636
- return de_DeleteImageCommandError(output, context);
769
+ return de_CommandError(output, context);
1637
770
  }
1638
771
  const data = await parseBody(output.body, context);
1639
772
  let contents = {};
1640
- contents = de_DeleteImageResult(data, context);
773
+ contents = _json(data);
1641
774
  const response = {
1642
775
  $metadata: deserializeMetadata(output),
1643
776
  ...contents,
1644
777
  };
1645
778
  return response;
1646
779
  };
1647
- const de_DeleteImageCommandError = async (output, context) => {
1648
- const parsedOutput = {
1649
- ...output,
1650
- body: await parseErrorBody(output.body, context),
1651
- };
1652
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1653
- switch (errorCode) {
1654
- case "ConcurrentModificationException":
1655
- case "com.amazonaws.appstream#ConcurrentModificationException":
1656
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1657
- case "OperationNotPermittedException":
1658
- case "com.amazonaws.appstream#OperationNotPermittedException":
1659
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
1660
- case "ResourceInUseException":
1661
- case "com.amazonaws.appstream#ResourceInUseException":
1662
- throw await de_ResourceInUseExceptionRes(parsedOutput, context);
1663
- case "ResourceNotFoundException":
1664
- case "com.amazonaws.appstream#ResourceNotFoundException":
1665
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1666
- default:
1667
- const parsedBody = parsedOutput.body;
1668
- return throwDefaultError({
1669
- output,
1670
- parsedBody,
1671
- errorCode,
1672
- });
1673
- }
1674
- };
1675
- export const de_DeleteImageBuilderCommand = async (output, context) => {
780
+ export const de_DeleteEntitlementCommand = async (output, context) => {
1676
781
  if (output.statusCode >= 300) {
1677
- return de_DeleteImageBuilderCommandError(output, context);
782
+ return de_CommandError(output, context);
1678
783
  }
1679
784
  const data = await parseBody(output.body, context);
1680
785
  let contents = {};
1681
- contents = de_DeleteImageBuilderResult(data, context);
786
+ contents = _json(data);
1682
787
  const response = {
1683
788
  $metadata: deserializeMetadata(output),
1684
789
  ...contents,
1685
790
  };
1686
791
  return response;
1687
792
  };
1688
- const de_DeleteImageBuilderCommandError = async (output, context) => {
1689
- const parsedOutput = {
1690
- ...output,
1691
- body: await parseErrorBody(output.body, context),
1692
- };
1693
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1694
- switch (errorCode) {
1695
- case "ConcurrentModificationException":
1696
- case "com.amazonaws.appstream#ConcurrentModificationException":
1697
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1698
- case "OperationNotPermittedException":
1699
- case "com.amazonaws.appstream#OperationNotPermittedException":
1700
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
1701
- case "ResourceNotFoundException":
1702
- case "com.amazonaws.appstream#ResourceNotFoundException":
1703
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1704
- default:
1705
- const parsedBody = parsedOutput.body;
1706
- return throwDefaultError({
1707
- output,
1708
- parsedBody,
1709
- errorCode,
1710
- });
1711
- }
1712
- };
1713
- export const de_DeleteImagePermissionsCommand = async (output, context) => {
793
+ export const de_DeleteFleetCommand = async (output, context) => {
1714
794
  if (output.statusCode >= 300) {
1715
- return de_DeleteImagePermissionsCommandError(output, context);
795
+ return de_CommandError(output, context);
1716
796
  }
1717
797
  const data = await parseBody(output.body, context);
1718
798
  let contents = {};
@@ -1723,72 +803,35 @@ export const de_DeleteImagePermissionsCommand = async (output, context) => {
1723
803
  };
1724
804
  return response;
1725
805
  };
1726
- const de_DeleteImagePermissionsCommandError = async (output, context) => {
1727
- const parsedOutput = {
1728
- ...output,
1729
- body: await parseErrorBody(output.body, context),
1730
- };
1731
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1732
- switch (errorCode) {
1733
- case "ResourceNotAvailableException":
1734
- case "com.amazonaws.appstream#ResourceNotAvailableException":
1735
- throw await de_ResourceNotAvailableExceptionRes(parsedOutput, context);
1736
- case "ResourceNotFoundException":
1737
- case "com.amazonaws.appstream#ResourceNotFoundException":
1738
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1739
- default:
1740
- const parsedBody = parsedOutput.body;
1741
- return throwDefaultError({
1742
- output,
1743
- parsedBody,
1744
- errorCode,
1745
- });
1746
- }
1747
- };
1748
- export const de_DeleteStackCommand = async (output, context) => {
806
+ export const de_DeleteImageCommand = async (output, context) => {
1749
807
  if (output.statusCode >= 300) {
1750
- return de_DeleteStackCommandError(output, context);
808
+ return de_CommandError(output, context);
1751
809
  }
1752
810
  const data = await parseBody(output.body, context);
1753
811
  let contents = {};
1754
- contents = _json(data);
812
+ contents = de_DeleteImageResult(data, context);
1755
813
  const response = {
1756
814
  $metadata: deserializeMetadata(output),
1757
815
  ...contents,
1758
816
  };
1759
817
  return response;
1760
818
  };
1761
- const de_DeleteStackCommandError = async (output, context) => {
1762
- const parsedOutput = {
1763
- ...output,
1764
- body: await parseErrorBody(output.body, context),
1765
- };
1766
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1767
- switch (errorCode) {
1768
- case "ConcurrentModificationException":
1769
- case "com.amazonaws.appstream#ConcurrentModificationException":
1770
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1771
- case "OperationNotPermittedException":
1772
- case "com.amazonaws.appstream#OperationNotPermittedException":
1773
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
1774
- case "ResourceInUseException":
1775
- case "com.amazonaws.appstream#ResourceInUseException":
1776
- throw await de_ResourceInUseExceptionRes(parsedOutput, context);
1777
- case "ResourceNotFoundException":
1778
- case "com.amazonaws.appstream#ResourceNotFoundException":
1779
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1780
- default:
1781
- const parsedBody = parsedOutput.body;
1782
- return throwDefaultError({
1783
- output,
1784
- parsedBody,
1785
- errorCode,
1786
- });
819
+ export const de_DeleteImageBuilderCommand = async (output, context) => {
820
+ if (output.statusCode >= 300) {
821
+ return de_CommandError(output, context);
1787
822
  }
823
+ const data = await parseBody(output.body, context);
824
+ let contents = {};
825
+ contents = de_DeleteImageBuilderResult(data, context);
826
+ const response = {
827
+ $metadata: deserializeMetadata(output),
828
+ ...contents,
829
+ };
830
+ return response;
1788
831
  };
1789
- export const de_DeleteUsageReportSubscriptionCommand = async (output, context) => {
832
+ export const de_DeleteImagePermissionsCommand = async (output, context) => {
1790
833
  if (output.statusCode >= 300) {
1791
- return de_DeleteUsageReportSubscriptionCommandError(output, context);
834
+ return de_CommandError(output, context);
1792
835
  }
1793
836
  const data = await parseBody(output.body, context);
1794
837
  let contents = {};
@@ -1799,31 +842,22 @@ export const de_DeleteUsageReportSubscriptionCommand = async (output, context) =
1799
842
  };
1800
843
  return response;
1801
844
  };
1802
- const de_DeleteUsageReportSubscriptionCommandError = async (output, context) => {
1803
- const parsedOutput = {
1804
- ...output,
1805
- body: await parseErrorBody(output.body, context),
1806
- };
1807
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1808
- switch (errorCode) {
1809
- case "InvalidAccountStatusException":
1810
- case "com.amazonaws.appstream#InvalidAccountStatusException":
1811
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
1812
- case "ResourceNotFoundException":
1813
- case "com.amazonaws.appstream#ResourceNotFoundException":
1814
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1815
- default:
1816
- const parsedBody = parsedOutput.body;
1817
- return throwDefaultError({
1818
- output,
1819
- parsedBody,
1820
- errorCode,
1821
- });
845
+ export const de_DeleteStackCommand = async (output, context) => {
846
+ if (output.statusCode >= 300) {
847
+ return de_CommandError(output, context);
1822
848
  }
849
+ const data = await parseBody(output.body, context);
850
+ let contents = {};
851
+ contents = _json(data);
852
+ const response = {
853
+ $metadata: deserializeMetadata(output),
854
+ ...contents,
855
+ };
856
+ return response;
1823
857
  };
1824
- export const de_DeleteUserCommand = async (output, context) => {
858
+ export const de_DeleteUsageReportSubscriptionCommand = async (output, context) => {
1825
859
  if (output.statusCode >= 300) {
1826
- return de_DeleteUserCommandError(output, context);
860
+ return de_CommandError(output, context);
1827
861
  }
1828
862
  const data = await parseBody(output.body, context);
1829
863
  let contents = {};
@@ -1834,28 +868,22 @@ export const de_DeleteUserCommand = async (output, context) => {
1834
868
  };
1835
869
  return response;
1836
870
  };
1837
- const de_DeleteUserCommandError = async (output, context) => {
1838
- const parsedOutput = {
1839
- ...output,
1840
- body: await parseErrorBody(output.body, context),
1841
- };
1842
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1843
- switch (errorCode) {
1844
- case "ResourceNotFoundException":
1845
- case "com.amazonaws.appstream#ResourceNotFoundException":
1846
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1847
- default:
1848
- const parsedBody = parsedOutput.body;
1849
- return throwDefaultError({
1850
- output,
1851
- parsedBody,
1852
- errorCode,
1853
- });
871
+ export const de_DeleteUserCommand = async (output, context) => {
872
+ if (output.statusCode >= 300) {
873
+ return de_CommandError(output, context);
1854
874
  }
875
+ const data = await parseBody(output.body, context);
876
+ let contents = {};
877
+ contents = _json(data);
878
+ const response = {
879
+ $metadata: deserializeMetadata(output),
880
+ ...contents,
881
+ };
882
+ return response;
1855
883
  };
1856
884
  export const de_DescribeAppBlockBuilderAppBlockAssociationsCommand = async (output, context) => {
1857
885
  if (output.statusCode >= 300) {
1858
- return de_DescribeAppBlockBuilderAppBlockAssociationsCommandError(output, context);
886
+ return de_CommandError(output, context);
1859
887
  }
1860
888
  const data = await parseBody(output.body, context);
1861
889
  let contents = {};
@@ -1866,31 +894,9 @@ export const de_DescribeAppBlockBuilderAppBlockAssociationsCommand = async (outp
1866
894
  };
1867
895
  return response;
1868
896
  };
1869
- const de_DescribeAppBlockBuilderAppBlockAssociationsCommandError = async (output, context) => {
1870
- const parsedOutput = {
1871
- ...output,
1872
- body: await parseErrorBody(output.body, context),
1873
- };
1874
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1875
- switch (errorCode) {
1876
- case "InvalidParameterCombinationException":
1877
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
1878
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
1879
- case "OperationNotPermittedException":
1880
- case "com.amazonaws.appstream#OperationNotPermittedException":
1881
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
1882
- default:
1883
- const parsedBody = parsedOutput.body;
1884
- return throwDefaultError({
1885
- output,
1886
- parsedBody,
1887
- errorCode,
1888
- });
1889
- }
1890
- };
1891
897
  export const de_DescribeAppBlockBuildersCommand = async (output, context) => {
1892
898
  if (output.statusCode >= 300) {
1893
- return de_DescribeAppBlockBuildersCommandError(output, context);
899
+ return de_CommandError(output, context);
1894
900
  }
1895
901
  const data = await parseBody(output.body, context);
1896
902
  let contents = {};
@@ -1901,31 +907,9 @@ export const de_DescribeAppBlockBuildersCommand = async (output, context) => {
1901
907
  };
1902
908
  return response;
1903
909
  };
1904
- const de_DescribeAppBlockBuildersCommandError = async (output, context) => {
1905
- const parsedOutput = {
1906
- ...output,
1907
- body: await parseErrorBody(output.body, context),
1908
- };
1909
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1910
- switch (errorCode) {
1911
- case "OperationNotPermittedException":
1912
- case "com.amazonaws.appstream#OperationNotPermittedException":
1913
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
1914
- case "ResourceNotFoundException":
1915
- case "com.amazonaws.appstream#ResourceNotFoundException":
1916
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1917
- default:
1918
- const parsedBody = parsedOutput.body;
1919
- return throwDefaultError({
1920
- output,
1921
- parsedBody,
1922
- errorCode,
1923
- });
1924
- }
1925
- };
1926
910
  export const de_DescribeAppBlocksCommand = async (output, context) => {
1927
911
  if (output.statusCode >= 300) {
1928
- return de_DescribeAppBlocksCommandError(output, context);
912
+ return de_CommandError(output, context);
1929
913
  }
1930
914
  const data = await parseBody(output.body, context);
1931
915
  let contents = {};
@@ -1936,31 +920,9 @@ export const de_DescribeAppBlocksCommand = async (output, context) => {
1936
920
  };
1937
921
  return response;
1938
922
  };
1939
- const de_DescribeAppBlocksCommandError = async (output, context) => {
1940
- const parsedOutput = {
1941
- ...output,
1942
- body: await parseErrorBody(output.body, context),
1943
- };
1944
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1945
- switch (errorCode) {
1946
- case "OperationNotPermittedException":
1947
- case "com.amazonaws.appstream#OperationNotPermittedException":
1948
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
1949
- case "ResourceNotFoundException":
1950
- case "com.amazonaws.appstream#ResourceNotFoundException":
1951
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1952
- default:
1953
- const parsedBody = parsedOutput.body;
1954
- return throwDefaultError({
1955
- output,
1956
- parsedBody,
1957
- errorCode,
1958
- });
1959
- }
1960
- };
1961
923
  export const de_DescribeApplicationFleetAssociationsCommand = async (output, context) => {
1962
924
  if (output.statusCode >= 300) {
1963
- return de_DescribeApplicationFleetAssociationsCommandError(output, context);
925
+ return de_CommandError(output, context);
1964
926
  }
1965
927
  const data = await parseBody(output.body, context);
1966
928
  let contents = {};
@@ -1971,31 +933,9 @@ export const de_DescribeApplicationFleetAssociationsCommand = async (output, con
1971
933
  };
1972
934
  return response;
1973
935
  };
1974
- const de_DescribeApplicationFleetAssociationsCommandError = async (output, context) => {
1975
- const parsedOutput = {
1976
- ...output,
1977
- body: await parseErrorBody(output.body, context),
1978
- };
1979
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1980
- switch (errorCode) {
1981
- case "InvalidParameterCombinationException":
1982
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
1983
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
1984
- case "OperationNotPermittedException":
1985
- case "com.amazonaws.appstream#OperationNotPermittedException":
1986
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
1987
- default:
1988
- const parsedBody = parsedOutput.body;
1989
- return throwDefaultError({
1990
- output,
1991
- parsedBody,
1992
- errorCode,
1993
- });
1994
- }
1995
- };
1996
936
  export const de_DescribeApplicationsCommand = async (output, context) => {
1997
937
  if (output.statusCode >= 300) {
1998
- return de_DescribeApplicationsCommandError(output, context);
938
+ return de_CommandError(output, context);
1999
939
  }
2000
940
  const data = await parseBody(output.body, context);
2001
941
  let contents = {};
@@ -2006,31 +946,9 @@ export const de_DescribeApplicationsCommand = async (output, context) => {
2006
946
  };
2007
947
  return response;
2008
948
  };
2009
- const de_DescribeApplicationsCommandError = async (output, context) => {
2010
- const parsedOutput = {
2011
- ...output,
2012
- body: await parseErrorBody(output.body, context),
2013
- };
2014
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2015
- switch (errorCode) {
2016
- case "OperationNotPermittedException":
2017
- case "com.amazonaws.appstream#OperationNotPermittedException":
2018
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
2019
- case "ResourceNotFoundException":
2020
- case "com.amazonaws.appstream#ResourceNotFoundException":
2021
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2022
- default:
2023
- const parsedBody = parsedOutput.body;
2024
- return throwDefaultError({
2025
- output,
2026
- parsedBody,
2027
- errorCode,
2028
- });
2029
- }
2030
- };
2031
949
  export const de_DescribeDirectoryConfigsCommand = async (output, context) => {
2032
950
  if (output.statusCode >= 300) {
2033
- return de_DescribeDirectoryConfigsCommandError(output, context);
951
+ return de_CommandError(output, context);
2034
952
  }
2035
953
  const data = await parseBody(output.body, context);
2036
954
  let contents = {};
@@ -2041,28 +959,9 @@ export const de_DescribeDirectoryConfigsCommand = async (output, context) => {
2041
959
  };
2042
960
  return response;
2043
961
  };
2044
- const de_DescribeDirectoryConfigsCommandError = async (output, context) => {
2045
- const parsedOutput = {
2046
- ...output,
2047
- body: await parseErrorBody(output.body, context),
2048
- };
2049
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2050
- switch (errorCode) {
2051
- case "ResourceNotFoundException":
2052
- case "com.amazonaws.appstream#ResourceNotFoundException":
2053
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2054
- default:
2055
- const parsedBody = parsedOutput.body;
2056
- return throwDefaultError({
2057
- output,
2058
- parsedBody,
2059
- errorCode,
2060
- });
2061
- }
2062
- };
2063
962
  export const de_DescribeEntitlementsCommand = async (output, context) => {
2064
963
  if (output.statusCode >= 300) {
2065
- return de_DescribeEntitlementsCommandError(output, context);
964
+ return de_CommandError(output, context);
2066
965
  }
2067
966
  const data = await parseBody(output.body, context);
2068
967
  let contents = {};
@@ -2073,34 +972,9 @@ export const de_DescribeEntitlementsCommand = async (output, context) => {
2073
972
  };
2074
973
  return response;
2075
974
  };
2076
- const de_DescribeEntitlementsCommandError = async (output, context) => {
2077
- const parsedOutput = {
2078
- ...output,
2079
- body: await parseErrorBody(output.body, context),
2080
- };
2081
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2082
- switch (errorCode) {
2083
- case "EntitlementNotFoundException":
2084
- case "com.amazonaws.appstream#EntitlementNotFoundException":
2085
- throw await de_EntitlementNotFoundExceptionRes(parsedOutput, context);
2086
- case "OperationNotPermittedException":
2087
- case "com.amazonaws.appstream#OperationNotPermittedException":
2088
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
2089
- case "ResourceNotFoundException":
2090
- case "com.amazonaws.appstream#ResourceNotFoundException":
2091
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2092
- default:
2093
- const parsedBody = parsedOutput.body;
2094
- return throwDefaultError({
2095
- output,
2096
- parsedBody,
2097
- errorCode,
2098
- });
2099
- }
2100
- };
2101
975
  export const de_DescribeFleetsCommand = async (output, context) => {
2102
976
  if (output.statusCode >= 300) {
2103
- return de_DescribeFleetsCommandError(output, context);
977
+ return de_CommandError(output, context);
2104
978
  }
2105
979
  const data = await parseBody(output.body, context);
2106
980
  let contents = {};
@@ -2111,28 +985,9 @@ export const de_DescribeFleetsCommand = async (output, context) => {
2111
985
  };
2112
986
  return response;
2113
987
  };
2114
- const de_DescribeFleetsCommandError = async (output, context) => {
2115
- const parsedOutput = {
2116
- ...output,
2117
- body: await parseErrorBody(output.body, context),
2118
- };
2119
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2120
- switch (errorCode) {
2121
- case "ResourceNotFoundException":
2122
- case "com.amazonaws.appstream#ResourceNotFoundException":
2123
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2124
- default:
2125
- const parsedBody = parsedOutput.body;
2126
- return throwDefaultError({
2127
- output,
2128
- parsedBody,
2129
- errorCode,
2130
- });
2131
- }
2132
- };
2133
988
  export const de_DescribeImageBuildersCommand = async (output, context) => {
2134
989
  if (output.statusCode >= 300) {
2135
- return de_DescribeImageBuildersCommandError(output, context);
990
+ return de_CommandError(output, context);
2136
991
  }
2137
992
  const data = await parseBody(output.body, context);
2138
993
  let contents = {};
@@ -2143,28 +998,9 @@ export const de_DescribeImageBuildersCommand = async (output, context) => {
2143
998
  };
2144
999
  return response;
2145
1000
  };
2146
- const de_DescribeImageBuildersCommandError = async (output, context) => {
2147
- const parsedOutput = {
2148
- ...output,
2149
- body: await parseErrorBody(output.body, context),
2150
- };
2151
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2152
- switch (errorCode) {
2153
- case "ResourceNotFoundException":
2154
- case "com.amazonaws.appstream#ResourceNotFoundException":
2155
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2156
- default:
2157
- const parsedBody = parsedOutput.body;
2158
- return throwDefaultError({
2159
- output,
2160
- parsedBody,
2161
- errorCode,
2162
- });
2163
- }
2164
- };
2165
1001
  export const de_DescribeImagePermissionsCommand = async (output, context) => {
2166
1002
  if (output.statusCode >= 300) {
2167
- return de_DescribeImagePermissionsCommandError(output, context);
1003
+ return de_CommandError(output, context);
2168
1004
  }
2169
1005
  const data = await parseBody(output.body, context);
2170
1006
  let contents = {};
@@ -2175,63 +1011,22 @@ export const de_DescribeImagePermissionsCommand = async (output, context) => {
2175
1011
  };
2176
1012
  return response;
2177
1013
  };
2178
- const de_DescribeImagePermissionsCommandError = async (output, context) => {
2179
- const parsedOutput = {
2180
- ...output,
2181
- body: await parseErrorBody(output.body, context),
2182
- };
2183
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2184
- switch (errorCode) {
2185
- case "ResourceNotFoundException":
2186
- case "com.amazonaws.appstream#ResourceNotFoundException":
2187
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2188
- default:
2189
- const parsedBody = parsedOutput.body;
2190
- return throwDefaultError({
2191
- output,
2192
- parsedBody,
2193
- errorCode,
2194
- });
2195
- }
2196
- };
2197
1014
  export const de_DescribeImagesCommand = async (output, context) => {
2198
1015
  if (output.statusCode >= 300) {
2199
- return de_DescribeImagesCommandError(output, context);
1016
+ return de_CommandError(output, context);
2200
1017
  }
2201
1018
  const data = await parseBody(output.body, context);
2202
1019
  let contents = {};
2203
1020
  contents = de_DescribeImagesResult(data, context);
2204
- const response = {
2205
- $metadata: deserializeMetadata(output),
2206
- ...contents,
2207
- };
2208
- return response;
2209
- };
2210
- const de_DescribeImagesCommandError = async (output, context) => {
2211
- const parsedOutput = {
2212
- ...output,
2213
- body: await parseErrorBody(output.body, context),
2214
- };
2215
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2216
- switch (errorCode) {
2217
- case "InvalidParameterCombinationException":
2218
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
2219
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
2220
- case "ResourceNotFoundException":
2221
- case "com.amazonaws.appstream#ResourceNotFoundException":
2222
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2223
- default:
2224
- const parsedBody = parsedOutput.body;
2225
- return throwDefaultError({
2226
- output,
2227
- parsedBody,
2228
- errorCode,
2229
- });
2230
- }
1021
+ const response = {
1022
+ $metadata: deserializeMetadata(output),
1023
+ ...contents,
1024
+ };
1025
+ return response;
2231
1026
  };
2232
1027
  export const de_DescribeSessionsCommand = async (output, context) => {
2233
1028
  if (output.statusCode >= 300) {
2234
- return de_DescribeSessionsCommandError(output, context);
1029
+ return de_CommandError(output, context);
2235
1030
  }
2236
1031
  const data = await parseBody(output.body, context);
2237
1032
  let contents = {};
@@ -2242,28 +1037,9 @@ export const de_DescribeSessionsCommand = async (output, context) => {
2242
1037
  };
2243
1038
  return response;
2244
1039
  };
2245
- const de_DescribeSessionsCommandError = async (output, context) => {
2246
- const parsedOutput = {
2247
- ...output,
2248
- body: await parseErrorBody(output.body, context),
2249
- };
2250
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2251
- switch (errorCode) {
2252
- case "InvalidParameterCombinationException":
2253
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
2254
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
2255
- default:
2256
- const parsedBody = parsedOutput.body;
2257
- return throwDefaultError({
2258
- output,
2259
- parsedBody,
2260
- errorCode,
2261
- });
2262
- }
2263
- };
2264
1040
  export const de_DescribeStacksCommand = async (output, context) => {
2265
1041
  if (output.statusCode >= 300) {
2266
- return de_DescribeStacksCommandError(output, context);
1042
+ return de_CommandError(output, context);
2267
1043
  }
2268
1044
  const data = await parseBody(output.body, context);
2269
1045
  let contents = {};
@@ -2274,28 +1050,9 @@ export const de_DescribeStacksCommand = async (output, context) => {
2274
1050
  };
2275
1051
  return response;
2276
1052
  };
2277
- const de_DescribeStacksCommandError = async (output, context) => {
2278
- const parsedOutput = {
2279
- ...output,
2280
- body: await parseErrorBody(output.body, context),
2281
- };
2282
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2283
- switch (errorCode) {
2284
- case "ResourceNotFoundException":
2285
- case "com.amazonaws.appstream#ResourceNotFoundException":
2286
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2287
- default:
2288
- const parsedBody = parsedOutput.body;
2289
- return throwDefaultError({
2290
- output,
2291
- parsedBody,
2292
- errorCode,
2293
- });
2294
- }
2295
- };
2296
1053
  export const de_DescribeUsageReportSubscriptionsCommand = async (output, context) => {
2297
1054
  if (output.statusCode >= 300) {
2298
- return de_DescribeUsageReportSubscriptionsCommandError(output, context);
1055
+ return de_CommandError(output, context);
2299
1056
  }
2300
1057
  const data = await parseBody(output.body, context);
2301
1058
  let contents = {};
@@ -2306,31 +1063,9 @@ export const de_DescribeUsageReportSubscriptionsCommand = async (output, context
2306
1063
  };
2307
1064
  return response;
2308
1065
  };
2309
- const de_DescribeUsageReportSubscriptionsCommandError = async (output, context) => {
2310
- const parsedOutput = {
2311
- ...output,
2312
- body: await parseErrorBody(output.body, context),
2313
- };
2314
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2315
- switch (errorCode) {
2316
- case "InvalidAccountStatusException":
2317
- case "com.amazonaws.appstream#InvalidAccountStatusException":
2318
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
2319
- case "ResourceNotFoundException":
2320
- case "com.amazonaws.appstream#ResourceNotFoundException":
2321
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2322
- default:
2323
- const parsedBody = parsedOutput.body;
2324
- return throwDefaultError({
2325
- output,
2326
- parsedBody,
2327
- errorCode,
2328
- });
2329
- }
2330
- };
2331
1066
  export const de_DescribeUsersCommand = async (output, context) => {
2332
1067
  if (output.statusCode >= 300) {
2333
- return de_DescribeUsersCommandError(output, context);
1068
+ return de_CommandError(output, context);
2334
1069
  }
2335
1070
  const data = await parseBody(output.body, context);
2336
1071
  let contents = {};
@@ -2341,34 +1076,9 @@ export const de_DescribeUsersCommand = async (output, context) => {
2341
1076
  };
2342
1077
  return response;
2343
1078
  };
2344
- const de_DescribeUsersCommandError = async (output, context) => {
2345
- const parsedOutput = {
2346
- ...output,
2347
- body: await parseErrorBody(output.body, context),
2348
- };
2349
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2350
- switch (errorCode) {
2351
- case "InvalidParameterCombinationException":
2352
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
2353
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
2354
- case "OperationNotPermittedException":
2355
- case "com.amazonaws.appstream#OperationNotPermittedException":
2356
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
2357
- case "ResourceNotFoundException":
2358
- case "com.amazonaws.appstream#ResourceNotFoundException":
2359
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2360
- default:
2361
- const parsedBody = parsedOutput.body;
2362
- return throwDefaultError({
2363
- output,
2364
- parsedBody,
2365
- errorCode,
2366
- });
2367
- }
2368
- };
2369
1079
  export const de_DescribeUserStackAssociationsCommand = async (output, context) => {
2370
1080
  if (output.statusCode >= 300) {
2371
- return de_DescribeUserStackAssociationsCommandError(output, context);
1081
+ return de_CommandError(output, context);
2372
1082
  }
2373
1083
  const data = await parseBody(output.body, context);
2374
1084
  let contents = {};
@@ -2379,31 +1089,9 @@ export const de_DescribeUserStackAssociationsCommand = async (output, context) =
2379
1089
  };
2380
1090
  return response;
2381
1091
  };
2382
- const de_DescribeUserStackAssociationsCommandError = async (output, context) => {
2383
- const parsedOutput = {
2384
- ...output,
2385
- body: await parseErrorBody(output.body, context),
2386
- };
2387
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2388
- switch (errorCode) {
2389
- case "InvalidParameterCombinationException":
2390
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
2391
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
2392
- case "OperationNotPermittedException":
2393
- case "com.amazonaws.appstream#OperationNotPermittedException":
2394
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
2395
- default:
2396
- const parsedBody = parsedOutput.body;
2397
- return throwDefaultError({
2398
- output,
2399
- parsedBody,
2400
- errorCode,
2401
- });
2402
- }
2403
- };
2404
1092
  export const de_DisableUserCommand = async (output, context) => {
2405
1093
  if (output.statusCode >= 300) {
2406
- return de_DisableUserCommandError(output, context);
1094
+ return de_CommandError(output, context);
2407
1095
  }
2408
1096
  const data = await parseBody(output.body, context);
2409
1097
  let contents = {};
@@ -2414,28 +1102,9 @@ export const de_DisableUserCommand = async (output, context) => {
2414
1102
  };
2415
1103
  return response;
2416
1104
  };
2417
- const de_DisableUserCommandError = async (output, context) => {
2418
- const parsedOutput = {
2419
- ...output,
2420
- body: await parseErrorBody(output.body, context),
2421
- };
2422
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2423
- switch (errorCode) {
2424
- case "ResourceNotFoundException":
2425
- case "com.amazonaws.appstream#ResourceNotFoundException":
2426
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2427
- default:
2428
- const parsedBody = parsedOutput.body;
2429
- return throwDefaultError({
2430
- output,
2431
- parsedBody,
2432
- errorCode,
2433
- });
2434
- }
2435
- };
2436
1105
  export const de_DisassociateAppBlockBuilderAppBlockCommand = async (output, context) => {
2437
1106
  if (output.statusCode >= 300) {
2438
- return de_DisassociateAppBlockBuilderAppBlockCommandError(output, context);
1107
+ return de_CommandError(output, context);
2439
1108
  }
2440
1109
  const data = await parseBody(output.body, context);
2441
1110
  let contents = {};
@@ -2446,37 +1115,9 @@ export const de_DisassociateAppBlockBuilderAppBlockCommand = async (output, cont
2446
1115
  };
2447
1116
  return response;
2448
1117
  };
2449
- const de_DisassociateAppBlockBuilderAppBlockCommandError = async (output, context) => {
2450
- const parsedOutput = {
2451
- ...output,
2452
- body: await parseErrorBody(output.body, context),
2453
- };
2454
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2455
- switch (errorCode) {
2456
- case "ConcurrentModificationException":
2457
- case "com.amazonaws.appstream#ConcurrentModificationException":
2458
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2459
- case "InvalidParameterCombinationException":
2460
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
2461
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
2462
- case "OperationNotPermittedException":
2463
- case "com.amazonaws.appstream#OperationNotPermittedException":
2464
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
2465
- case "ResourceNotFoundException":
2466
- case "com.amazonaws.appstream#ResourceNotFoundException":
2467
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2468
- default:
2469
- const parsedBody = parsedOutput.body;
2470
- return throwDefaultError({
2471
- output,
2472
- parsedBody,
2473
- errorCode,
2474
- });
2475
- }
2476
- };
2477
1118
  export const de_DisassociateApplicationFleetCommand = async (output, context) => {
2478
1119
  if (output.statusCode >= 300) {
2479
- return de_DisassociateApplicationFleetCommandError(output, context);
1120
+ return de_CommandError(output, context);
2480
1121
  }
2481
1122
  const data = await parseBody(output.body, context);
2482
1123
  let contents = {};
@@ -2487,34 +1128,9 @@ export const de_DisassociateApplicationFleetCommand = async (output, context) =>
2487
1128
  };
2488
1129
  return response;
2489
1130
  };
2490
- const de_DisassociateApplicationFleetCommandError = async (output, context) => {
2491
- const parsedOutput = {
2492
- ...output,
2493
- body: await parseErrorBody(output.body, context),
2494
- };
2495
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2496
- switch (errorCode) {
2497
- case "ConcurrentModificationException":
2498
- case "com.amazonaws.appstream#ConcurrentModificationException":
2499
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2500
- case "InvalidParameterCombinationException":
2501
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
2502
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
2503
- case "OperationNotPermittedException":
2504
- case "com.amazonaws.appstream#OperationNotPermittedException":
2505
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
2506
- default:
2507
- const parsedBody = parsedOutput.body;
2508
- return throwDefaultError({
2509
- output,
2510
- parsedBody,
2511
- errorCode,
2512
- });
2513
- }
2514
- };
2515
1131
  export const de_DisassociateApplicationFromEntitlementCommand = async (output, context) => {
2516
1132
  if (output.statusCode >= 300) {
2517
- return de_DisassociateApplicationFromEntitlementCommandError(output, context);
1133
+ return de_CommandError(output, context);
2518
1134
  }
2519
1135
  const data = await parseBody(output.body, context);
2520
1136
  let contents = {};
@@ -2525,34 +1141,9 @@ export const de_DisassociateApplicationFromEntitlementCommand = async (output, c
2525
1141
  };
2526
1142
  return response;
2527
1143
  };
2528
- const de_DisassociateApplicationFromEntitlementCommandError = async (output, context) => {
2529
- const parsedOutput = {
2530
- ...output,
2531
- body: await parseErrorBody(output.body, context),
2532
- };
2533
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2534
- switch (errorCode) {
2535
- case "EntitlementNotFoundException":
2536
- case "com.amazonaws.appstream#EntitlementNotFoundException":
2537
- throw await de_EntitlementNotFoundExceptionRes(parsedOutput, context);
2538
- case "OperationNotPermittedException":
2539
- case "com.amazonaws.appstream#OperationNotPermittedException":
2540
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
2541
- case "ResourceNotFoundException":
2542
- case "com.amazonaws.appstream#ResourceNotFoundException":
2543
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2544
- default:
2545
- const parsedBody = parsedOutput.body;
2546
- return throwDefaultError({
2547
- output,
2548
- parsedBody,
2549
- errorCode,
2550
- });
2551
- }
2552
- };
2553
1144
  export const de_DisassociateFleetCommand = async (output, context) => {
2554
1145
  if (output.statusCode >= 300) {
2555
- return de_DisassociateFleetCommandError(output, context);
1146
+ return de_CommandError(output, context);
2556
1147
  }
2557
1148
  const data = await parseBody(output.body, context);
2558
1149
  let contents = {};
@@ -2563,37 +1154,9 @@ export const de_DisassociateFleetCommand = async (output, context) => {
2563
1154
  };
2564
1155
  return response;
2565
1156
  };
2566
- const de_DisassociateFleetCommandError = async (output, context) => {
2567
- const parsedOutput = {
2568
- ...output,
2569
- body: await parseErrorBody(output.body, context),
2570
- };
2571
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2572
- switch (errorCode) {
2573
- case "ConcurrentModificationException":
2574
- case "com.amazonaws.appstream#ConcurrentModificationException":
2575
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2576
- case "OperationNotPermittedException":
2577
- case "com.amazonaws.appstream#OperationNotPermittedException":
2578
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
2579
- case "ResourceInUseException":
2580
- case "com.amazonaws.appstream#ResourceInUseException":
2581
- throw await de_ResourceInUseExceptionRes(parsedOutput, context);
2582
- case "ResourceNotFoundException":
2583
- case "com.amazonaws.appstream#ResourceNotFoundException":
2584
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2585
- default:
2586
- const parsedBody = parsedOutput.body;
2587
- return throwDefaultError({
2588
- output,
2589
- parsedBody,
2590
- errorCode,
2591
- });
2592
- }
2593
- };
2594
1157
  export const de_EnableUserCommand = async (output, context) => {
2595
1158
  if (output.statusCode >= 300) {
2596
- return de_EnableUserCommandError(output, context);
1159
+ return de_CommandError(output, context);
2597
1160
  }
2598
1161
  const data = await parseBody(output.body, context);
2599
1162
  let contents = {};
@@ -2604,31 +1167,9 @@ export const de_EnableUserCommand = async (output, context) => {
2604
1167
  };
2605
1168
  return response;
2606
1169
  };
2607
- const de_EnableUserCommandError = async (output, context) => {
2608
- const parsedOutput = {
2609
- ...output,
2610
- body: await parseErrorBody(output.body, context),
2611
- };
2612
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2613
- switch (errorCode) {
2614
- case "InvalidAccountStatusException":
2615
- case "com.amazonaws.appstream#InvalidAccountStatusException":
2616
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
2617
- case "ResourceNotFoundException":
2618
- case "com.amazonaws.appstream#ResourceNotFoundException":
2619
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2620
- default:
2621
- const parsedBody = parsedOutput.body;
2622
- return throwDefaultError({
2623
- output,
2624
- parsedBody,
2625
- errorCode,
2626
- });
2627
- }
2628
- };
2629
1170
  export const de_ExpireSessionCommand = async (output, context) => {
2630
1171
  if (output.statusCode >= 300) {
2631
- return de_ExpireSessionCommandError(output, context);
1172
+ return de_CommandError(output, context);
2632
1173
  }
2633
1174
  const data = await parseBody(output.body, context);
2634
1175
  let contents = {};
@@ -2637,24 +1178,11 @@ export const de_ExpireSessionCommand = async (output, context) => {
2637
1178
  $metadata: deserializeMetadata(output),
2638
1179
  ...contents,
2639
1180
  };
2640
- return response;
2641
- };
2642
- const de_ExpireSessionCommandError = async (output, context) => {
2643
- const parsedOutput = {
2644
- ...output,
2645
- body: await parseErrorBody(output.body, context),
2646
- };
2647
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2648
- const parsedBody = parsedOutput.body;
2649
- return throwDefaultError({
2650
- output,
2651
- parsedBody,
2652
- errorCode,
2653
- });
1181
+ return response;
2654
1182
  };
2655
1183
  export const de_ListAssociatedFleetsCommand = async (output, context) => {
2656
1184
  if (output.statusCode >= 300) {
2657
- return de_ListAssociatedFleetsCommandError(output, context);
1185
+ return de_CommandError(output, context);
2658
1186
  }
2659
1187
  const data = await parseBody(output.body, context);
2660
1188
  let contents = {};
@@ -2665,22 +1193,9 @@ export const de_ListAssociatedFleetsCommand = async (output, context) => {
2665
1193
  };
2666
1194
  return response;
2667
1195
  };
2668
- const de_ListAssociatedFleetsCommandError = async (output, context) => {
2669
- const parsedOutput = {
2670
- ...output,
2671
- body: await parseErrorBody(output.body, context),
2672
- };
2673
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2674
- const parsedBody = parsedOutput.body;
2675
- return throwDefaultError({
2676
- output,
2677
- parsedBody,
2678
- errorCode,
2679
- });
2680
- };
2681
1196
  export const de_ListAssociatedStacksCommand = async (output, context) => {
2682
1197
  if (output.statusCode >= 300) {
2683
- return de_ListAssociatedStacksCommandError(output, context);
1198
+ return de_CommandError(output, context);
2684
1199
  }
2685
1200
  const data = await parseBody(output.body, context);
2686
1201
  let contents = {};
@@ -2691,22 +1206,9 @@ export const de_ListAssociatedStacksCommand = async (output, context) => {
2691
1206
  };
2692
1207
  return response;
2693
1208
  };
2694
- const de_ListAssociatedStacksCommandError = async (output, context) => {
2695
- const parsedOutput = {
2696
- ...output,
2697
- body: await parseErrorBody(output.body, context),
2698
- };
2699
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2700
- const parsedBody = parsedOutput.body;
2701
- return throwDefaultError({
2702
- output,
2703
- parsedBody,
2704
- errorCode,
2705
- });
2706
- };
2707
1209
  export const de_ListEntitledApplicationsCommand = async (output, context) => {
2708
1210
  if (output.statusCode >= 300) {
2709
- return de_ListEntitledApplicationsCommandError(output, context);
1211
+ return de_CommandError(output, context);
2710
1212
  }
2711
1213
  const data = await parseBody(output.body, context);
2712
1214
  let contents = {};
@@ -2717,34 +1219,9 @@ export const de_ListEntitledApplicationsCommand = async (output, context) => {
2717
1219
  };
2718
1220
  return response;
2719
1221
  };
2720
- const de_ListEntitledApplicationsCommandError = async (output, context) => {
2721
- const parsedOutput = {
2722
- ...output,
2723
- body: await parseErrorBody(output.body, context),
2724
- };
2725
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2726
- switch (errorCode) {
2727
- case "EntitlementNotFoundException":
2728
- case "com.amazonaws.appstream#EntitlementNotFoundException":
2729
- throw await de_EntitlementNotFoundExceptionRes(parsedOutput, context);
2730
- case "OperationNotPermittedException":
2731
- case "com.amazonaws.appstream#OperationNotPermittedException":
2732
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
2733
- case "ResourceNotFoundException":
2734
- case "com.amazonaws.appstream#ResourceNotFoundException":
2735
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2736
- default:
2737
- const parsedBody = parsedOutput.body;
2738
- return throwDefaultError({
2739
- output,
2740
- parsedBody,
2741
- errorCode,
2742
- });
2743
- }
2744
- };
2745
1222
  export const de_ListTagsForResourceCommand = async (output, context) => {
2746
1223
  if (output.statusCode >= 300) {
2747
- return de_ListTagsForResourceCommandError(output, context);
1224
+ return de_CommandError(output, context);
2748
1225
  }
2749
1226
  const data = await parseBody(output.body, context);
2750
1227
  let contents = {};
@@ -2755,28 +1232,9 @@ export const de_ListTagsForResourceCommand = async (output, context) => {
2755
1232
  };
2756
1233
  return response;
2757
1234
  };
2758
- const de_ListTagsForResourceCommandError = async (output, context) => {
2759
- const parsedOutput = {
2760
- ...output,
2761
- body: await parseErrorBody(output.body, context),
2762
- };
2763
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2764
- switch (errorCode) {
2765
- case "ResourceNotFoundException":
2766
- case "com.amazonaws.appstream#ResourceNotFoundException":
2767
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2768
- default:
2769
- const parsedBody = parsedOutput.body;
2770
- return throwDefaultError({
2771
- output,
2772
- parsedBody,
2773
- errorCode,
2774
- });
2775
- }
2776
- };
2777
1235
  export const de_StartAppBlockBuilderCommand = async (output, context) => {
2778
1236
  if (output.statusCode >= 300) {
2779
- return de_StartAppBlockBuilderCommandError(output, context);
1237
+ return de_CommandError(output, context);
2780
1238
  }
2781
1239
  const data = await parseBody(output.body, context);
2782
1240
  let contents = {};
@@ -2787,46 +1245,9 @@ export const de_StartAppBlockBuilderCommand = async (output, context) => {
2787
1245
  };
2788
1246
  return response;
2789
1247
  };
2790
- const de_StartAppBlockBuilderCommandError = async (output, context) => {
2791
- const parsedOutput = {
2792
- ...output,
2793
- body: await parseErrorBody(output.body, context),
2794
- };
2795
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2796
- switch (errorCode) {
2797
- case "ConcurrentModificationException":
2798
- case "com.amazonaws.appstream#ConcurrentModificationException":
2799
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2800
- case "InvalidAccountStatusException":
2801
- case "com.amazonaws.appstream#InvalidAccountStatusException":
2802
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
2803
- case "LimitExceededException":
2804
- case "com.amazonaws.appstream#LimitExceededException":
2805
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2806
- case "OperationNotPermittedException":
2807
- case "com.amazonaws.appstream#OperationNotPermittedException":
2808
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
2809
- case "RequestLimitExceededException":
2810
- case "com.amazonaws.appstream#RequestLimitExceededException":
2811
- throw await de_RequestLimitExceededExceptionRes(parsedOutput, context);
2812
- case "ResourceNotAvailableException":
2813
- case "com.amazonaws.appstream#ResourceNotAvailableException":
2814
- throw await de_ResourceNotAvailableExceptionRes(parsedOutput, context);
2815
- case "ResourceNotFoundException":
2816
- case "com.amazonaws.appstream#ResourceNotFoundException":
2817
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2818
- default:
2819
- const parsedBody = parsedOutput.body;
2820
- return throwDefaultError({
2821
- output,
2822
- parsedBody,
2823
- errorCode,
2824
- });
2825
- }
2826
- };
2827
1248
  export const de_StartFleetCommand = async (output, context) => {
2828
1249
  if (output.statusCode >= 300) {
2829
- return de_StartFleetCommandError(output, context);
1250
+ return de_CommandError(output, context);
2830
1251
  }
2831
1252
  const data = await parseBody(output.body, context);
2832
1253
  let contents = {};
@@ -2837,49 +1258,9 @@ export const de_StartFleetCommand = async (output, context) => {
2837
1258
  };
2838
1259
  return response;
2839
1260
  };
2840
- const de_StartFleetCommandError = async (output, context) => {
2841
- const parsedOutput = {
2842
- ...output,
2843
- body: await parseErrorBody(output.body, context),
2844
- };
2845
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2846
- switch (errorCode) {
2847
- case "ConcurrentModificationException":
2848
- case "com.amazonaws.appstream#ConcurrentModificationException":
2849
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2850
- case "InvalidAccountStatusException":
2851
- case "com.amazonaws.appstream#InvalidAccountStatusException":
2852
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
2853
- case "InvalidRoleException":
2854
- case "com.amazonaws.appstream#InvalidRoleException":
2855
- throw await de_InvalidRoleExceptionRes(parsedOutput, context);
2856
- case "LimitExceededException":
2857
- case "com.amazonaws.appstream#LimitExceededException":
2858
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2859
- case "OperationNotPermittedException":
2860
- case "com.amazonaws.appstream#OperationNotPermittedException":
2861
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
2862
- case "RequestLimitExceededException":
2863
- case "com.amazonaws.appstream#RequestLimitExceededException":
2864
- throw await de_RequestLimitExceededExceptionRes(parsedOutput, context);
2865
- case "ResourceNotAvailableException":
2866
- case "com.amazonaws.appstream#ResourceNotAvailableException":
2867
- throw await de_ResourceNotAvailableExceptionRes(parsedOutput, context);
2868
- case "ResourceNotFoundException":
2869
- case "com.amazonaws.appstream#ResourceNotFoundException":
2870
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2871
- default:
2872
- const parsedBody = parsedOutput.body;
2873
- return throwDefaultError({
2874
- output,
2875
- parsedBody,
2876
- errorCode,
2877
- });
2878
- }
2879
- };
2880
1261
  export const de_StartImageBuilderCommand = async (output, context) => {
2881
1262
  if (output.statusCode >= 300) {
2882
- return de_StartImageBuilderCommandError(output, context);
1263
+ return de_CommandError(output, context);
2883
1264
  }
2884
1265
  const data = await parseBody(output.body, context);
2885
1266
  let contents = {};
@@ -2890,40 +1271,9 @@ export const de_StartImageBuilderCommand = async (output, context) => {
2890
1271
  };
2891
1272
  return response;
2892
1273
  };
2893
- const de_StartImageBuilderCommandError = async (output, context) => {
2894
- const parsedOutput = {
2895
- ...output,
2896
- body: await parseErrorBody(output.body, context),
2897
- };
2898
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2899
- switch (errorCode) {
2900
- case "ConcurrentModificationException":
2901
- case "com.amazonaws.appstream#ConcurrentModificationException":
2902
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2903
- case "IncompatibleImageException":
2904
- case "com.amazonaws.appstream#IncompatibleImageException":
2905
- throw await de_IncompatibleImageExceptionRes(parsedOutput, context);
2906
- case "InvalidAccountStatusException":
2907
- case "com.amazonaws.appstream#InvalidAccountStatusException":
2908
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
2909
- case "ResourceNotAvailableException":
2910
- case "com.amazonaws.appstream#ResourceNotAvailableException":
2911
- throw await de_ResourceNotAvailableExceptionRes(parsedOutput, context);
2912
- case "ResourceNotFoundException":
2913
- case "com.amazonaws.appstream#ResourceNotFoundException":
2914
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2915
- default:
2916
- const parsedBody = parsedOutput.body;
2917
- return throwDefaultError({
2918
- output,
2919
- parsedBody,
2920
- errorCode,
2921
- });
2922
- }
2923
- };
2924
1274
  export const de_StopAppBlockBuilderCommand = async (output, context) => {
2925
1275
  if (output.statusCode >= 300) {
2926
- return de_StopAppBlockBuilderCommandError(output, context);
1276
+ return de_CommandError(output, context);
2927
1277
  }
2928
1278
  const data = await parseBody(output.body, context);
2929
1279
  let contents = {};
@@ -2934,34 +1284,9 @@ export const de_StopAppBlockBuilderCommand = async (output, context) => {
2934
1284
  };
2935
1285
  return response;
2936
1286
  };
2937
- const de_StopAppBlockBuilderCommandError = async (output, context) => {
2938
- const parsedOutput = {
2939
- ...output,
2940
- body: await parseErrorBody(output.body, context),
2941
- };
2942
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2943
- switch (errorCode) {
2944
- case "ConcurrentModificationException":
2945
- case "com.amazonaws.appstream#ConcurrentModificationException":
2946
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2947
- case "OperationNotPermittedException":
2948
- case "com.amazonaws.appstream#OperationNotPermittedException":
2949
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
2950
- case "ResourceNotFoundException":
2951
- case "com.amazonaws.appstream#ResourceNotFoundException":
2952
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2953
- default:
2954
- const parsedBody = parsedOutput.body;
2955
- return throwDefaultError({
2956
- output,
2957
- parsedBody,
2958
- errorCode,
2959
- });
2960
- }
2961
- };
2962
1287
  export const de_StopFleetCommand = async (output, context) => {
2963
1288
  if (output.statusCode >= 300) {
2964
- return de_StopFleetCommandError(output, context);
1289
+ return de_CommandError(output, context);
2965
1290
  }
2966
1291
  const data = await parseBody(output.body, context);
2967
1292
  let contents = {};
@@ -2972,31 +1297,9 @@ export const de_StopFleetCommand = async (output, context) => {
2972
1297
  };
2973
1298
  return response;
2974
1299
  };
2975
- const de_StopFleetCommandError = async (output, context) => {
2976
- const parsedOutput = {
2977
- ...output,
2978
- body: await parseErrorBody(output.body, context),
2979
- };
2980
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2981
- switch (errorCode) {
2982
- case "ConcurrentModificationException":
2983
- case "com.amazonaws.appstream#ConcurrentModificationException":
2984
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2985
- case "ResourceNotFoundException":
2986
- case "com.amazonaws.appstream#ResourceNotFoundException":
2987
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2988
- default:
2989
- const parsedBody = parsedOutput.body;
2990
- return throwDefaultError({
2991
- output,
2992
- parsedBody,
2993
- errorCode,
2994
- });
2995
- }
2996
- };
2997
1300
  export const de_StopImageBuilderCommand = async (output, context) => {
2998
1301
  if (output.statusCode >= 300) {
2999
- return de_StopImageBuilderCommandError(output, context);
1302
+ return de_CommandError(output, context);
3000
1303
  }
3001
1304
  const data = await parseBody(output.body, context);
3002
1305
  let contents = {};
@@ -3007,34 +1310,9 @@ export const de_StopImageBuilderCommand = async (output, context) => {
3007
1310
  };
3008
1311
  return response;
3009
1312
  };
3010
- const de_StopImageBuilderCommandError = async (output, context) => {
3011
- const parsedOutput = {
3012
- ...output,
3013
- body: await parseErrorBody(output.body, context),
3014
- };
3015
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3016
- switch (errorCode) {
3017
- case "ConcurrentModificationException":
3018
- case "com.amazonaws.appstream#ConcurrentModificationException":
3019
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3020
- case "OperationNotPermittedException":
3021
- case "com.amazonaws.appstream#OperationNotPermittedException":
3022
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
3023
- case "ResourceNotFoundException":
3024
- case "com.amazonaws.appstream#ResourceNotFoundException":
3025
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3026
- default:
3027
- const parsedBody = parsedOutput.body;
3028
- return throwDefaultError({
3029
- output,
3030
- parsedBody,
3031
- errorCode,
3032
- });
3033
- }
3034
- };
3035
1313
  export const de_TagResourceCommand = async (output, context) => {
3036
1314
  if (output.statusCode >= 300) {
3037
- return de_TagResourceCommandError(output, context);
1315
+ return de_CommandError(output, context);
3038
1316
  }
3039
1317
  const data = await parseBody(output.body, context);
3040
1318
  let contents = {};
@@ -3043,36 +1321,11 @@ export const de_TagResourceCommand = async (output, context) => {
3043
1321
  $metadata: deserializeMetadata(output),
3044
1322
  ...contents,
3045
1323
  };
3046
- return response;
3047
- };
3048
- const de_TagResourceCommandError = async (output, context) => {
3049
- const parsedOutput = {
3050
- ...output,
3051
- body: await parseErrorBody(output.body, context),
3052
- };
3053
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3054
- switch (errorCode) {
3055
- case "InvalidAccountStatusException":
3056
- case "com.amazonaws.appstream#InvalidAccountStatusException":
3057
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
3058
- case "LimitExceededException":
3059
- case "com.amazonaws.appstream#LimitExceededException":
3060
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3061
- case "ResourceNotFoundException":
3062
- case "com.amazonaws.appstream#ResourceNotFoundException":
3063
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3064
- default:
3065
- const parsedBody = parsedOutput.body;
3066
- return throwDefaultError({
3067
- output,
3068
- parsedBody,
3069
- errorCode,
3070
- });
3071
- }
1324
+ return response;
3072
1325
  };
3073
1326
  export const de_UntagResourceCommand = async (output, context) => {
3074
1327
  if (output.statusCode >= 300) {
3075
- return de_UntagResourceCommandError(output, context);
1328
+ return de_CommandError(output, context);
3076
1329
  }
3077
1330
  const data = await parseBody(output.body, context);
3078
1331
  let contents = {};
@@ -3083,28 +1336,9 @@ export const de_UntagResourceCommand = async (output, context) => {
3083
1336
  };
3084
1337
  return response;
3085
1338
  };
3086
- const de_UntagResourceCommandError = async (output, context) => {
3087
- const parsedOutput = {
3088
- ...output,
3089
- body: await parseErrorBody(output.body, context),
3090
- };
3091
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3092
- switch (errorCode) {
3093
- case "ResourceNotFoundException":
3094
- case "com.amazonaws.appstream#ResourceNotFoundException":
3095
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3096
- default:
3097
- const parsedBody = parsedOutput.body;
3098
- return throwDefaultError({
3099
- output,
3100
- parsedBody,
3101
- errorCode,
3102
- });
3103
- }
3104
- };
3105
1339
  export const de_UpdateAppBlockBuilderCommand = async (output, context) => {
3106
1340
  if (output.statusCode >= 300) {
3107
- return de_UpdateAppBlockBuilderCommandError(output, context);
1341
+ return de_CommandError(output, context);
3108
1342
  }
3109
1343
  const data = await parseBody(output.body, context);
3110
1344
  let contents = {};
@@ -3115,55 +1349,9 @@ export const de_UpdateAppBlockBuilderCommand = async (output, context) => {
3115
1349
  };
3116
1350
  return response;
3117
1351
  };
3118
- const de_UpdateAppBlockBuilderCommandError = async (output, context) => {
3119
- const parsedOutput = {
3120
- ...output,
3121
- body: await parseErrorBody(output.body, context),
3122
- };
3123
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3124
- switch (errorCode) {
3125
- case "ConcurrentModificationException":
3126
- case "com.amazonaws.appstream#ConcurrentModificationException":
3127
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3128
- case "InvalidAccountStatusException":
3129
- case "com.amazonaws.appstream#InvalidAccountStatusException":
3130
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
3131
- case "InvalidParameterCombinationException":
3132
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
3133
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
3134
- case "InvalidRoleException":
3135
- case "com.amazonaws.appstream#InvalidRoleException":
3136
- throw await de_InvalidRoleExceptionRes(parsedOutput, context);
3137
- case "LimitExceededException":
3138
- case "com.amazonaws.appstream#LimitExceededException":
3139
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3140
- case "OperationNotPermittedException":
3141
- case "com.amazonaws.appstream#OperationNotPermittedException":
3142
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
3143
- case "RequestLimitExceededException":
3144
- case "com.amazonaws.appstream#RequestLimitExceededException":
3145
- throw await de_RequestLimitExceededExceptionRes(parsedOutput, context);
3146
- case "ResourceInUseException":
3147
- case "com.amazonaws.appstream#ResourceInUseException":
3148
- throw await de_ResourceInUseExceptionRes(parsedOutput, context);
3149
- case "ResourceNotAvailableException":
3150
- case "com.amazonaws.appstream#ResourceNotAvailableException":
3151
- throw await de_ResourceNotAvailableExceptionRes(parsedOutput, context);
3152
- case "ResourceNotFoundException":
3153
- case "com.amazonaws.appstream#ResourceNotFoundException":
3154
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3155
- default:
3156
- const parsedBody = parsedOutput.body;
3157
- return throwDefaultError({
3158
- output,
3159
- parsedBody,
3160
- errorCode,
3161
- });
3162
- }
3163
- };
3164
1352
  export const de_UpdateApplicationCommand = async (output, context) => {
3165
1353
  if (output.statusCode >= 300) {
3166
- return de_UpdateApplicationCommandError(output, context);
1354
+ return de_CommandError(output, context);
3167
1355
  }
3168
1356
  const data = await parseBody(output.body, context);
3169
1357
  let contents = {};
@@ -3174,34 +1362,9 @@ export const de_UpdateApplicationCommand = async (output, context) => {
3174
1362
  };
3175
1363
  return response;
3176
1364
  };
3177
- const de_UpdateApplicationCommandError = async (output, context) => {
3178
- const parsedOutput = {
3179
- ...output,
3180
- body: await parseErrorBody(output.body, context),
3181
- };
3182
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3183
- switch (errorCode) {
3184
- case "ConcurrentModificationException":
3185
- case "com.amazonaws.appstream#ConcurrentModificationException":
3186
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3187
- case "OperationNotPermittedException":
3188
- case "com.amazonaws.appstream#OperationNotPermittedException":
3189
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
3190
- case "ResourceNotFoundException":
3191
- case "com.amazonaws.appstream#ResourceNotFoundException":
3192
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3193
- default:
3194
- const parsedBody = parsedOutput.body;
3195
- return throwDefaultError({
3196
- output,
3197
- parsedBody,
3198
- errorCode,
3199
- });
3200
- }
3201
- };
3202
1365
  export const de_UpdateDirectoryConfigCommand = async (output, context) => {
3203
1366
  if (output.statusCode >= 300) {
3204
- return de_UpdateDirectoryConfigCommandError(output, context);
1367
+ return de_CommandError(output, context);
3205
1368
  }
3206
1369
  const data = await parseBody(output.body, context);
3207
1370
  let contents = {};
@@ -3212,40 +1375,9 @@ export const de_UpdateDirectoryConfigCommand = async (output, context) => {
3212
1375
  };
3213
1376
  return response;
3214
1377
  };
3215
- const de_UpdateDirectoryConfigCommandError = async (output, context) => {
3216
- const parsedOutput = {
3217
- ...output,
3218
- body: await parseErrorBody(output.body, context),
3219
- };
3220
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3221
- switch (errorCode) {
3222
- case "ConcurrentModificationException":
3223
- case "com.amazonaws.appstream#ConcurrentModificationException":
3224
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3225
- case "InvalidRoleException":
3226
- case "com.amazonaws.appstream#InvalidRoleException":
3227
- throw await de_InvalidRoleExceptionRes(parsedOutput, context);
3228
- case "OperationNotPermittedException":
3229
- case "com.amazonaws.appstream#OperationNotPermittedException":
3230
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
3231
- case "ResourceInUseException":
3232
- case "com.amazonaws.appstream#ResourceInUseException":
3233
- throw await de_ResourceInUseExceptionRes(parsedOutput, context);
3234
- case "ResourceNotFoundException":
3235
- case "com.amazonaws.appstream#ResourceNotFoundException":
3236
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3237
- default:
3238
- const parsedBody = parsedOutput.body;
3239
- return throwDefaultError({
3240
- output,
3241
- parsedBody,
3242
- errorCode,
3243
- });
3244
- }
3245
- };
3246
1378
  export const de_UpdateEntitlementCommand = async (output, context) => {
3247
1379
  if (output.statusCode >= 300) {
3248
- return de_UpdateEntitlementCommandError(output, context);
1380
+ return de_CommandError(output, context);
3249
1381
  }
3250
1382
  const data = await parseBody(output.body, context);
3251
1383
  let contents = {};
@@ -3256,37 +1388,9 @@ export const de_UpdateEntitlementCommand = async (output, context) => {
3256
1388
  };
3257
1389
  return response;
3258
1390
  };
3259
- const de_UpdateEntitlementCommandError = async (output, context) => {
3260
- const parsedOutput = {
3261
- ...output,
3262
- body: await parseErrorBody(output.body, context),
3263
- };
3264
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3265
- switch (errorCode) {
3266
- case "ConcurrentModificationException":
3267
- case "com.amazonaws.appstream#ConcurrentModificationException":
3268
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3269
- case "EntitlementNotFoundException":
3270
- case "com.amazonaws.appstream#EntitlementNotFoundException":
3271
- throw await de_EntitlementNotFoundExceptionRes(parsedOutput, context);
3272
- case "OperationNotPermittedException":
3273
- case "com.amazonaws.appstream#OperationNotPermittedException":
3274
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
3275
- case "ResourceNotFoundException":
3276
- case "com.amazonaws.appstream#ResourceNotFoundException":
3277
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3278
- default:
3279
- const parsedBody = parsedOutput.body;
3280
- return throwDefaultError({
3281
- output,
3282
- parsedBody,
3283
- errorCode,
3284
- });
3285
- }
3286
- };
3287
1391
  export const de_UpdateFleetCommand = async (output, context) => {
3288
1392
  if (output.statusCode >= 300) {
3289
- return de_UpdateFleetCommandError(output, context);
1393
+ return de_CommandError(output, context);
3290
1394
  }
3291
1395
  const data = await parseBody(output.body, context);
3292
1396
  let contents = {};
@@ -3297,58 +1401,9 @@ export const de_UpdateFleetCommand = async (output, context) => {
3297
1401
  };
3298
1402
  return response;
3299
1403
  };
3300
- const de_UpdateFleetCommandError = async (output, context) => {
3301
- const parsedOutput = {
3302
- ...output,
3303
- body: await parseErrorBody(output.body, context),
3304
- };
3305
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3306
- switch (errorCode) {
3307
- case "ConcurrentModificationException":
3308
- case "com.amazonaws.appstream#ConcurrentModificationException":
3309
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3310
- case "IncompatibleImageException":
3311
- case "com.amazonaws.appstream#IncompatibleImageException":
3312
- throw await de_IncompatibleImageExceptionRes(parsedOutput, context);
3313
- case "InvalidAccountStatusException":
3314
- case "com.amazonaws.appstream#InvalidAccountStatusException":
3315
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
3316
- case "InvalidParameterCombinationException":
3317
- case "com.amazonaws.appstream#InvalidParameterCombinationException":
3318
- throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
3319
- case "InvalidRoleException":
3320
- case "com.amazonaws.appstream#InvalidRoleException":
3321
- throw await de_InvalidRoleExceptionRes(parsedOutput, context);
3322
- case "LimitExceededException":
3323
- case "com.amazonaws.appstream#LimitExceededException":
3324
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3325
- case "OperationNotPermittedException":
3326
- case "com.amazonaws.appstream#OperationNotPermittedException":
3327
- throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
3328
- case "RequestLimitExceededException":
3329
- case "com.amazonaws.appstream#RequestLimitExceededException":
3330
- throw await de_RequestLimitExceededExceptionRes(parsedOutput, context);
3331
- case "ResourceInUseException":
3332
- case "com.amazonaws.appstream#ResourceInUseException":
3333
- throw await de_ResourceInUseExceptionRes(parsedOutput, context);
3334
- case "ResourceNotAvailableException":
3335
- case "com.amazonaws.appstream#ResourceNotAvailableException":
3336
- throw await de_ResourceNotAvailableExceptionRes(parsedOutput, context);
3337
- case "ResourceNotFoundException":
3338
- case "com.amazonaws.appstream#ResourceNotFoundException":
3339
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3340
- default:
3341
- const parsedBody = parsedOutput.body;
3342
- return throwDefaultError({
3343
- output,
3344
- parsedBody,
3345
- errorCode,
3346
- });
3347
- }
3348
- };
3349
1404
  export const de_UpdateImagePermissionsCommand = async (output, context) => {
3350
1405
  if (output.statusCode >= 300) {
3351
- return de_UpdateImagePermissionsCommandError(output, context);
1406
+ return de_CommandError(output, context);
3352
1407
  }
3353
1408
  const data = await parseBody(output.body, context);
3354
1409
  let contents = {};
@@ -3359,34 +1414,9 @@ export const de_UpdateImagePermissionsCommand = async (output, context) => {
3359
1414
  };
3360
1415
  return response;
3361
1416
  };
3362
- const de_UpdateImagePermissionsCommandError = async (output, context) => {
3363
- const parsedOutput = {
3364
- ...output,
3365
- body: await parseErrorBody(output.body, context),
3366
- };
3367
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3368
- switch (errorCode) {
3369
- case "LimitExceededException":
3370
- case "com.amazonaws.appstream#LimitExceededException":
3371
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3372
- case "ResourceNotAvailableException":
3373
- case "com.amazonaws.appstream#ResourceNotAvailableException":
3374
- throw await de_ResourceNotAvailableExceptionRes(parsedOutput, context);
3375
- case "ResourceNotFoundException":
3376
- case "com.amazonaws.appstream#ResourceNotFoundException":
3377
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3378
- default:
3379
- const parsedBody = parsedOutput.body;
3380
- return throwDefaultError({
3381
- output,
3382
- parsedBody,
3383
- errorCode,
3384
- });
3385
- }
3386
- };
3387
1417
  export const de_UpdateStackCommand = async (output, context) => {
3388
1418
  if (output.statusCode >= 300) {
3389
- return de_UpdateStackCommandError(output, context);
1419
+ return de_CommandError(output, context);
3390
1420
  }
3391
1421
  const data = await parseBody(output.body, context);
3392
1422
  let contents = {};
@@ -3397,7 +1427,7 @@ export const de_UpdateStackCommand = async (output, context) => {
3397
1427
  };
3398
1428
  return response;
3399
1429
  };
3400
- const de_UpdateStackCommandError = async (output, context) => {
1430
+ const de_CommandError = async (output, context) => {
3401
1431
  const parsedOutput = {
3402
1432
  ...output,
3403
1433
  body: await parseErrorBody(output.body, context),
@@ -3407,30 +1437,45 @@ const de_UpdateStackCommandError = async (output, context) => {
3407
1437
  case "ConcurrentModificationException":
3408
1438
  case "com.amazonaws.appstream#ConcurrentModificationException":
3409
1439
  throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
3410
- case "IncompatibleImageException":
3411
- case "com.amazonaws.appstream#IncompatibleImageException":
3412
- throw await de_IncompatibleImageExceptionRes(parsedOutput, context);
3413
- case "InvalidAccountStatusException":
3414
- case "com.amazonaws.appstream#InvalidAccountStatusException":
3415
- throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
3416
1440
  case "InvalidParameterCombinationException":
3417
1441
  case "com.amazonaws.appstream#InvalidParameterCombinationException":
3418
1442
  throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
3419
- case "InvalidRoleException":
3420
- case "com.amazonaws.appstream#InvalidRoleException":
3421
- throw await de_InvalidRoleExceptionRes(parsedOutput, context);
3422
1443
  case "LimitExceededException":
3423
1444
  case "com.amazonaws.appstream#LimitExceededException":
3424
1445
  throw await de_LimitExceededExceptionRes(parsedOutput, context);
3425
1446
  case "OperationNotPermittedException":
3426
1447
  case "com.amazonaws.appstream#OperationNotPermittedException":
3427
1448
  throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
3428
- case "ResourceInUseException":
3429
- case "com.amazonaws.appstream#ResourceInUseException":
3430
- throw await de_ResourceInUseExceptionRes(parsedOutput, context);
3431
1449
  case "ResourceNotFoundException":
3432
1450
  case "com.amazonaws.appstream#ResourceNotFoundException":
3433
1451
  throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1452
+ case "EntitlementNotFoundException":
1453
+ case "com.amazonaws.appstream#EntitlementNotFoundException":
1454
+ throw await de_EntitlementNotFoundExceptionRes(parsedOutput, context);
1455
+ case "IncompatibleImageException":
1456
+ case "com.amazonaws.appstream#IncompatibleImageException":
1457
+ throw await de_IncompatibleImageExceptionRes(parsedOutput, context);
1458
+ case "InvalidAccountStatusException":
1459
+ case "com.amazonaws.appstream#InvalidAccountStatusException":
1460
+ throw await de_InvalidAccountStatusExceptionRes(parsedOutput, context);
1461
+ case "ResourceAlreadyExistsException":
1462
+ case "com.amazonaws.appstream#ResourceAlreadyExistsException":
1463
+ throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
1464
+ case "ResourceNotAvailableException":
1465
+ case "com.amazonaws.appstream#ResourceNotAvailableException":
1466
+ throw await de_ResourceNotAvailableExceptionRes(parsedOutput, context);
1467
+ case "InvalidRoleException":
1468
+ case "com.amazonaws.appstream#InvalidRoleException":
1469
+ throw await de_InvalidRoleExceptionRes(parsedOutput, context);
1470
+ case "RequestLimitExceededException":
1471
+ case "com.amazonaws.appstream#RequestLimitExceededException":
1472
+ throw await de_RequestLimitExceededExceptionRes(parsedOutput, context);
1473
+ case "EntitlementAlreadyExistsException":
1474
+ case "com.amazonaws.appstream#EntitlementAlreadyExistsException":
1475
+ throw await de_EntitlementAlreadyExistsExceptionRes(parsedOutput, context);
1476
+ case "ResourceInUseException":
1477
+ case "com.amazonaws.appstream#ResourceInUseException":
1478
+ throw await de_ResourceInUseExceptionRes(parsedOutput, context);
3434
1479
  default:
3435
1480
  const parsedBody = parsedOutput.body;
3436
1481
  return throwDefaultError({