@aws-sdk/client-elastic-load-balancing-v2 3.52.0 → 3.54.1

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 (24) hide show
  1. package/CHANGELOG.md +27 -0
  2. package/dist-cjs/index.js +3 -0
  3. package/dist-cjs/models/ElasticLoadBalancingV2ServiceException.js +11 -0
  4. package/dist-cjs/models/models_0.js +523 -3
  5. package/dist-cjs/protocols/Aws_query.js +398 -1419
  6. package/dist-es/index.js +1 -0
  7. package/dist-es/models/ElasticLoadBalancingV2ServiceException.js +12 -0
  8. package/dist-es/models/models_0.js +483 -1
  9. package/dist-es/protocols/Aws_query.js +816 -1475
  10. package/dist-types/ElasticLoadBalancingV2Client.d.ts +2 -2
  11. package/dist-types/index.d.ts +1 -0
  12. package/dist-types/models/ElasticLoadBalancingV2ServiceException.d.ts +10 -0
  13. package/dist-types/models/models_0.d.ts +261 -112
  14. package/dist-types/runtimeConfig.browser.d.ts +1 -1
  15. package/dist-types/runtimeConfig.d.ts +1 -1
  16. package/dist-types/runtimeConfig.native.d.ts +1 -1
  17. package/dist-types/ts3.4/ElasticLoadBalancingV2Client.d.ts +2 -2
  18. package/dist-types/ts3.4/index.d.ts +1 -0
  19. package/dist-types/ts3.4/models/ElasticLoadBalancingV2ServiceException.d.ts +6 -0
  20. package/dist-types/ts3.4/models/models_0.d.ts +157 -94
  21. package/dist-types/ts3.4/runtimeConfig.browser.d.ts +1 -1
  22. package/dist-types/ts3.4/runtimeConfig.d.ts +1 -1
  23. package/dist-types/ts3.4/runtimeConfig.native.d.ts +1 -1
  24. package/package.json +28 -28
package/dist-cjs/protocols/Aws_query.js CHANGED
@@ -6,6 +6,8 @@ const protocol_http_1 = require("@aws-sdk/protocol-http");
6
6
  const smithy_client_1 = require("@aws-sdk/smithy-client");
7
7
  const entities_1 = require("entities");
8
8
  const fast_xml_parser_1 = require("fast-xml-parser");
9
+ const ElasticLoadBalancingV2ServiceException_1 = require("../models/ElasticLoadBalancingV2ServiceException");
10
+ const models_0_1 = require("../models/models_0");
9
11
  const serializeAws_queryAddListenerCertificatesCommand = async (input, context) => {
10
12
  const headers = {
11
13
  "content-type": "application/x-www-form-urlencoded",
@@ -473,43 +475,22 @@ const deserializeAws_queryAddListenerCertificatesCommandError = async (output, c
473
475
  switch (errorCode) {
474
476
  case "CertificateNotFoundException":
475
477
  case "com.amazonaws.elasticloadbalancingv2#CertificateNotFoundException":
476
- response = {
477
- ...(await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context)),
478
- name: errorCode,
479
- $metadata: deserializeMetadata(output),
480
- };
481
- break;
478
+ throw await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context);
482
479
  case "ListenerNotFoundException":
483
480
  case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
484
- response = {
485
- ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
486
- name: errorCode,
487
- $metadata: deserializeMetadata(output),
488
- };
489
- break;
481
+ throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
490
482
  case "TooManyCertificatesException":
491
483
  case "com.amazonaws.elasticloadbalancingv2#TooManyCertificatesException":
492
- response = {
493
- ...(await deserializeAws_queryTooManyCertificatesExceptionResponse(parsedOutput, context)),
494
- name: errorCode,
495
- $metadata: deserializeMetadata(output),
496
- };
497
- break;
484
+ throw await deserializeAws_queryTooManyCertificatesExceptionResponse(parsedOutput, context);
498
485
  default:
499
486
  const parsedBody = parsedOutput.body;
500
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
501
- response = {
502
- ...parsedBody.Error,
503
- name: `${errorCode}`,
504
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
487
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
488
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
505
489
  $fault: "client",
506
490
  $metadata: deserializeMetadata(output),
507
- };
491
+ });
492
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
508
493
  }
509
- const message = response.message || response.Message || errorCode;
510
- response.message = message;
511
- delete response.Message;
512
- return Promise.reject(Object.assign(new Error(message), response));
513
494
  };
514
495
  const deserializeAws_queryAddTagsCommand = async (output, context) => {
515
496
  if (output.statusCode >= 300) {
@@ -536,67 +517,31 @@ const deserializeAws_queryAddTagsCommandError = async (output, context) => {
536
517
  switch (errorCode) {
537
518
  case "DuplicateTagKeysException":
538
519
  case "com.amazonaws.elasticloadbalancingv2#DuplicateTagKeysException":
539
- response = {
540
- ...(await deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context)),
541
- name: errorCode,
542
- $metadata: deserializeMetadata(output),
543
- };
544
- break;
520
+ throw await deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context);
545
521
  case "ListenerNotFoundException":
546
522
  case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
547
- response = {
548
- ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
549
- name: errorCode,
550
- $metadata: deserializeMetadata(output),
551
- };
552
- break;
523
+ throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
553
524
  case "LoadBalancerNotFoundException":
554
525
  case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
555
- response = {
556
- ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
557
- name: errorCode,
558
- $metadata: deserializeMetadata(output),
559
- };
560
- break;
526
+ throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
561
527
  case "RuleNotFoundException":
562
528
  case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
563
- response = {
564
- ...(await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context)),
565
- name: errorCode,
566
- $metadata: deserializeMetadata(output),
567
- };
568
- break;
529
+ throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
569
530
  case "TargetGroupNotFoundException":
570
531
  case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
571
- response = {
572
- ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
573
- name: errorCode,
574
- $metadata: deserializeMetadata(output),
575
- };
576
- break;
532
+ throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
577
533
  case "TooManyTagsException":
578
534
  case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
579
- response = {
580
- ...(await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)),
581
- name: errorCode,
582
- $metadata: deserializeMetadata(output),
583
- };
584
- break;
535
+ throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
585
536
  default:
586
537
  const parsedBody = parsedOutput.body;
587
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
588
- response = {
589
- ...parsedBody.Error,
590
- name: `${errorCode}`,
591
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
538
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
539
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
592
540
  $fault: "client",
593
541
  $metadata: deserializeMetadata(output),
594
- };
542
+ });
543
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
595
544
  }
596
- const message = response.message || response.Message || errorCode;
597
- response.message = message;
598
- delete response.Message;
599
- return Promise.reject(Object.assign(new Error(message), response));
600
545
  };
601
546
  const deserializeAws_queryCreateListenerCommand = async (output, context) => {
602
547
  if (output.statusCode >= 300) {
@@ -623,163 +568,67 @@ const deserializeAws_queryCreateListenerCommandError = async (output, context) =
623
568
  switch (errorCode) {
624
569
  case "ALPNPolicyNotSupportedException":
625
570
  case "com.amazonaws.elasticloadbalancingv2#ALPNPolicyNotSupportedException":
626
- response = {
627
- ...(await deserializeAws_queryALPNPolicyNotSupportedExceptionResponse(parsedOutput, context)),
628
- name: errorCode,
629
- $metadata: deserializeMetadata(output),
630
- };
631
- break;
571
+ throw await deserializeAws_queryALPNPolicyNotSupportedExceptionResponse(parsedOutput, context);
632
572
  case "CertificateNotFoundException":
633
573
  case "com.amazonaws.elasticloadbalancingv2#CertificateNotFoundException":
634
- response = {
635
- ...(await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context)),
636
- name: errorCode,
637
- $metadata: deserializeMetadata(output),
638
- };
639
- break;
574
+ throw await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context);
640
575
  case "DuplicateListenerException":
641
576
  case "com.amazonaws.elasticloadbalancingv2#DuplicateListenerException":
642
- response = {
643
- ...(await deserializeAws_queryDuplicateListenerExceptionResponse(parsedOutput, context)),
644
- name: errorCode,
645
- $metadata: deserializeMetadata(output),
646
- };
647
- break;
577
+ throw await deserializeAws_queryDuplicateListenerExceptionResponse(parsedOutput, context);
648
578
  case "IncompatibleProtocolsException":
649
579
  case "com.amazonaws.elasticloadbalancingv2#IncompatibleProtocolsException":
650
- response = {
651
- ...(await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context)),
652
- name: errorCode,
653
- $metadata: deserializeMetadata(output),
654
- };
655
- break;
580
+ throw await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context);
656
581
  case "InvalidConfigurationRequestException":
657
582
  case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
658
- response = {
659
- ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
660
- name: errorCode,
661
- $metadata: deserializeMetadata(output),
662
- };
663
- break;
583
+ throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
664
584
  case "InvalidLoadBalancerActionException":
665
585
  case "com.amazonaws.elasticloadbalancingv2#InvalidLoadBalancerActionException":
666
- response = {
667
- ...(await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context)),
668
- name: errorCode,
669
- $metadata: deserializeMetadata(output),
670
- };
671
- break;
586
+ throw await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context);
672
587
  case "LoadBalancerNotFoundException":
673
588
  case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
674
- response = {
675
- ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
676
- name: errorCode,
677
- $metadata: deserializeMetadata(output),
678
- };
679
- break;
589
+ throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
680
590
  case "SSLPolicyNotFoundException":
681
591
  case "com.amazonaws.elasticloadbalancingv2#SSLPolicyNotFoundException":
682
- response = {
683
- ...(await deserializeAws_querySSLPolicyNotFoundExceptionResponse(parsedOutput, context)),
684
- name: errorCode,
685
- $metadata: deserializeMetadata(output),
686
- };
687
- break;
592
+ throw await deserializeAws_querySSLPolicyNotFoundExceptionResponse(parsedOutput, context);
688
593
  case "TargetGroupAssociationLimitException":
689
594
  case "com.amazonaws.elasticloadbalancingv2#TargetGroupAssociationLimitException":
690
- response = {
691
- ...(await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context)),
692
- name: errorCode,
693
- $metadata: deserializeMetadata(output),
694
- };
695
- break;
595
+ throw await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context);
696
596
  case "TargetGroupNotFoundException":
697
597
  case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
698
- response = {
699
- ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
700
- name: errorCode,
701
- $metadata: deserializeMetadata(output),
702
- };
703
- break;
598
+ throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
704
599
  case "TooManyActionsException":
705
600
  case "com.amazonaws.elasticloadbalancingv2#TooManyActionsException":
706
- response = {
707
- ...(await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context)),
708
- name: errorCode,
709
- $metadata: deserializeMetadata(output),
710
- };
711
- break;
601
+ throw await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context);
712
602
  case "TooManyCertificatesException":
713
603
  case "com.amazonaws.elasticloadbalancingv2#TooManyCertificatesException":
714
- response = {
715
- ...(await deserializeAws_queryTooManyCertificatesExceptionResponse(parsedOutput, context)),
716
- name: errorCode,
717
- $metadata: deserializeMetadata(output),
718
- };
719
- break;
604
+ throw await deserializeAws_queryTooManyCertificatesExceptionResponse(parsedOutput, context);
720
605
  case "TooManyListenersException":
721
606
  case "com.amazonaws.elasticloadbalancingv2#TooManyListenersException":
722
- response = {
723
- ...(await deserializeAws_queryTooManyListenersExceptionResponse(parsedOutput, context)),
724
- name: errorCode,
725
- $metadata: deserializeMetadata(output),
726
- };
727
- break;
607
+ throw await deserializeAws_queryTooManyListenersExceptionResponse(parsedOutput, context);
728
608
  case "TooManyRegistrationsForTargetIdException":
729
609
  case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
730
- response = {
731
- ...(await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context)),
732
- name: errorCode,
733
- $metadata: deserializeMetadata(output),
734
- };
735
- break;
610
+ throw await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context);
736
611
  case "TooManyTagsException":
737
612
  case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
738
- response = {
739
- ...(await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)),
740
- name: errorCode,
741
- $metadata: deserializeMetadata(output),
742
- };
743
- break;
613
+ throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
744
614
  case "TooManyTargetsException":
745
615
  case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
746
- response = {
747
- ...(await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context)),
748
- name: errorCode,
749
- $metadata: deserializeMetadata(output),
750
- };
751
- break;
616
+ throw await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context);
752
617
  case "TooManyUniqueTargetGroupsPerLoadBalancerException":
753
618
  case "com.amazonaws.elasticloadbalancingv2#TooManyUniqueTargetGroupsPerLoadBalancerException":
754
- response = {
755
- ...(await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context)),
756
- name: errorCode,
757
- $metadata: deserializeMetadata(output),
758
- };
759
- break;
619
+ throw await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context);
760
620
  case "UnsupportedProtocolException":
761
621
  case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
762
- response = {
763
- ...(await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)),
764
- name: errorCode,
765
- $metadata: deserializeMetadata(output),
766
- };
767
- break;
622
+ throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
768
623
  default:
769
624
  const parsedBody = parsedOutput.body;
770
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
771
- response = {
772
- ...parsedBody.Error,
773
- name: `${errorCode}`,
774
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
625
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
626
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
775
627
  $fault: "client",
776
628
  $metadata: deserializeMetadata(output),
777
- };
629
+ });
630
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
778
631
  }
779
- const message = response.message || response.Message || errorCode;
780
- response.message = message;
781
- delete response.Message;
782
- return Promise.reject(Object.assign(new Error(message), response));
783
632
  };
784
633
  const deserializeAws_queryCreateLoadBalancerCommand = async (output, context) => {
785
634
  if (output.statusCode >= 300) {
@@ -806,123 +655,52 @@ const deserializeAws_queryCreateLoadBalancerCommandError = async (output, contex
806
655
  switch (errorCode) {
807
656
  case "AllocationIdNotFoundException":
808
657
  case "com.amazonaws.elasticloadbalancingv2#AllocationIdNotFoundException":
809
- response = {
810
- ...(await deserializeAws_queryAllocationIdNotFoundExceptionResponse(parsedOutput, context)),
811
- name: errorCode,
812
- $metadata: deserializeMetadata(output),
813
- };
814
- break;
658
+ throw await deserializeAws_queryAllocationIdNotFoundExceptionResponse(parsedOutput, context);
815
659
  case "AvailabilityZoneNotSupportedException":
816
660
  case "com.amazonaws.elasticloadbalancingv2#AvailabilityZoneNotSupportedException":
817
- response = {
818
- ...(await deserializeAws_queryAvailabilityZoneNotSupportedExceptionResponse(parsedOutput, context)),
819
- name: errorCode,
820
- $metadata: deserializeMetadata(output),
821
- };
822
- break;
661
+ throw await deserializeAws_queryAvailabilityZoneNotSupportedExceptionResponse(parsedOutput, context);
823
662
  case "DuplicateLoadBalancerNameException":
824
663
  case "com.amazonaws.elasticloadbalancingv2#DuplicateLoadBalancerNameException":
825
- response = {
826
- ...(await deserializeAws_queryDuplicateLoadBalancerNameExceptionResponse(parsedOutput, context)),
827
- name: errorCode,
828
- $metadata: deserializeMetadata(output),
829
- };
830
- break;
664
+ throw await deserializeAws_queryDuplicateLoadBalancerNameExceptionResponse(parsedOutput, context);
831
665
  case "DuplicateTagKeysException":
832
666
  case "com.amazonaws.elasticloadbalancingv2#DuplicateTagKeysException":
833
- response = {
834
- ...(await deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context)),
835
- name: errorCode,
836
- $metadata: deserializeMetadata(output),
837
- };
838
- break;
667
+ throw await deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context);
839
668
  case "InvalidConfigurationRequestException":
840
669
  case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
841
- response = {
842
- ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
843
- name: errorCode,
844
- $metadata: deserializeMetadata(output),
845
- };
846
- break;
670
+ throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
847
671
  case "InvalidSchemeException":
848
672
  case "com.amazonaws.elasticloadbalancingv2#InvalidSchemeException":
849
- response = {
850
- ...(await deserializeAws_queryInvalidSchemeExceptionResponse(parsedOutput, context)),
851
- name: errorCode,
852
- $metadata: deserializeMetadata(output),
853
- };
854
- break;
673
+ throw await deserializeAws_queryInvalidSchemeExceptionResponse(parsedOutput, context);
855
674
  case "InvalidSecurityGroupException":
856
675
  case "com.amazonaws.elasticloadbalancingv2#InvalidSecurityGroupException":
857
- response = {
858
- ...(await deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context)),
859
- name: errorCode,
860
- $metadata: deserializeMetadata(output),
861
- };
862
- break;
676
+ throw await deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context);
863
677
  case "InvalidSubnetException":
864
678
  case "com.amazonaws.elasticloadbalancingv2#InvalidSubnetException":
865
- response = {
866
- ...(await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context)),
867
- name: errorCode,
868
- $metadata: deserializeMetadata(output),
869
- };
870
- break;
679
+ throw await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context);
871
680
  case "OperationNotPermittedException":
872
681
  case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
873
- response = {
874
- ...(await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context)),
875
- name: errorCode,
876
- $metadata: deserializeMetadata(output),
877
- };
878
- break;
682
+ throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
879
683
  case "ResourceInUseException":
880
684
  case "com.amazonaws.elasticloadbalancingv2#ResourceInUseException":
881
- response = {
882
- ...(await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context)),
883
- name: errorCode,
884
- $metadata: deserializeMetadata(output),
885
- };
886
- break;
685
+ throw await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context);
887
686
  case "SubnetNotFoundException":
888
687
  case "com.amazonaws.elasticloadbalancingv2#SubnetNotFoundException":
889
- response = {
890
- ...(await deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context)),
891
- name: errorCode,
892
- $metadata: deserializeMetadata(output),
893
- };
894
- break;
688
+ throw await deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context);
895
689
  case "TooManyLoadBalancersException":
896
690
  case "com.amazonaws.elasticloadbalancingv2#TooManyLoadBalancersException":
897
- response = {
898
- ...(await deserializeAws_queryTooManyLoadBalancersExceptionResponse(parsedOutput, context)),
899
- name: errorCode,
900
- $metadata: deserializeMetadata(output),
901
- };
902
- break;
691
+ throw await deserializeAws_queryTooManyLoadBalancersExceptionResponse(parsedOutput, context);
903
692
  case "TooManyTagsException":
904
693
  case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
905
- response = {
906
- ...(await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)),
907
- name: errorCode,
908
- $metadata: deserializeMetadata(output),
909
- };
910
- break;
694
+ throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
911
695
  default:
912
696
  const parsedBody = parsedOutput.body;
913
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
914
- response = {
915
- ...parsedBody.Error,
916
- name: `${errorCode}`,
917
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
697
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
698
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
918
699
  $fault: "client",
919
700
  $metadata: deserializeMetadata(output),
920
- };
701
+ });
702
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
921
703
  }
922
- const message = response.message || response.Message || errorCode;
923
- response.message = message;
924
- delete response.Message;
925
- return Promise.reject(Object.assign(new Error(message), response));
926
704
  };
927
705
  const deserializeAws_queryCreateRuleCommand = async (output, context) => {
928
706
  if (output.statusCode >= 300) {
@@ -949,139 +727,58 @@ const deserializeAws_queryCreateRuleCommandError = async (output, context) => {
949
727
  switch (errorCode) {
950
728
  case "IncompatibleProtocolsException":
951
729
  case "com.amazonaws.elasticloadbalancingv2#IncompatibleProtocolsException":
952
- response = {
953
- ...(await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context)),
954
- name: errorCode,
955
- $metadata: deserializeMetadata(output),
956
- };
957
- break;
730
+ throw await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context);
958
731
  case "InvalidConfigurationRequestException":
959
732
  case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
960
- response = {
961
- ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
962
- name: errorCode,
963
- $metadata: deserializeMetadata(output),
964
- };
965
- break;
733
+ throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
966
734
  case "InvalidLoadBalancerActionException":
967
735
  case "com.amazonaws.elasticloadbalancingv2#InvalidLoadBalancerActionException":
968
- response = {
969
- ...(await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context)),
970
- name: errorCode,
971
- $metadata: deserializeMetadata(output),
972
- };
973
- break;
736
+ throw await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context);
974
737
  case "ListenerNotFoundException":
975
738
  case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
976
- response = {
977
- ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
978
- name: errorCode,
979
- $metadata: deserializeMetadata(output),
980
- };
981
- break;
739
+ throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
982
740
  case "PriorityInUseException":
983
741
  case "com.amazonaws.elasticloadbalancingv2#PriorityInUseException":
984
- response = {
985
- ...(await deserializeAws_queryPriorityInUseExceptionResponse(parsedOutput, context)),
986
- name: errorCode,
987
- $metadata: deserializeMetadata(output),
988
- };
989
- break;
742
+ throw await deserializeAws_queryPriorityInUseExceptionResponse(parsedOutput, context);
990
743
  case "TargetGroupAssociationLimitException":
991
744
  case "com.amazonaws.elasticloadbalancingv2#TargetGroupAssociationLimitException":
992
- response = {
993
- ...(await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context)),
994
- name: errorCode,
995
- $metadata: deserializeMetadata(output),
996
- };
997
- break;
745
+ throw await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context);
998
746
  case "TargetGroupNotFoundException":
999
747
  case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
1000
- response = {
1001
- ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
1002
- name: errorCode,
1003
- $metadata: deserializeMetadata(output),
1004
- };
1005
- break;
748
+ throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
1006
749
  case "TooManyActionsException":
1007
750
  case "com.amazonaws.elasticloadbalancingv2#TooManyActionsException":
1008
- response = {
1009
- ...(await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context)),
1010
- name: errorCode,
1011
- $metadata: deserializeMetadata(output),
1012
- };
1013
- break;
751
+ throw await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context);
1014
752
  case "TooManyRegistrationsForTargetIdException":
1015
753
  case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
1016
- response = {
1017
- ...(await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context)),
1018
- name: errorCode,
1019
- $metadata: deserializeMetadata(output),
1020
- };
1021
- break;
754
+ throw await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context);
1022
755
  case "TooManyRulesException":
1023
756
  case "com.amazonaws.elasticloadbalancingv2#TooManyRulesException":
1024
- response = {
1025
- ...(await deserializeAws_queryTooManyRulesExceptionResponse(parsedOutput, context)),
1026
- name: errorCode,
1027
- $metadata: deserializeMetadata(output),
1028
- };
1029
- break;
757
+ throw await deserializeAws_queryTooManyRulesExceptionResponse(parsedOutput, context);
1030
758
  case "TooManyTagsException":
1031
759
  case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
1032
- response = {
1033
- ...(await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)),
1034
- name: errorCode,
1035
- $metadata: deserializeMetadata(output),
1036
- };
1037
- break;
760
+ throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
1038
761
  case "TooManyTargetGroupsException":
1039
762
  case "com.amazonaws.elasticloadbalancingv2#TooManyTargetGroupsException":
1040
- response = {
1041
- ...(await deserializeAws_queryTooManyTargetGroupsExceptionResponse(parsedOutput, context)),
1042
- name: errorCode,
1043
- $metadata: deserializeMetadata(output),
1044
- };
1045
- break;
763
+ throw await deserializeAws_queryTooManyTargetGroupsExceptionResponse(parsedOutput, context);
1046
764
  case "TooManyTargetsException":
1047
765
  case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
1048
- response = {
1049
- ...(await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context)),
1050
- name: errorCode,
1051
- $metadata: deserializeMetadata(output),
1052
- };
1053
- break;
766
+ throw await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context);
1054
767
  case "TooManyUniqueTargetGroupsPerLoadBalancerException":
1055
768
  case "com.amazonaws.elasticloadbalancingv2#TooManyUniqueTargetGroupsPerLoadBalancerException":
1056
- response = {
1057
- ...(await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context)),
1058
- name: errorCode,
1059
- $metadata: deserializeMetadata(output),
1060
- };
1061
- break;
769
+ throw await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context);
1062
770
  case "UnsupportedProtocolException":
1063
771
  case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
1064
- response = {
1065
- ...(await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)),
1066
- name: errorCode,
1067
- $metadata: deserializeMetadata(output),
1068
- };
1069
- break;
772
+ throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
1070
773
  default:
1071
774
  const parsedBody = parsedOutput.body;
1072
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1073
- response = {
1074
- ...parsedBody.Error,
1075
- name: `${errorCode}`,
1076
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
775
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
776
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1077
777
  $fault: "client",
1078
778
  $metadata: deserializeMetadata(output),
1079
- };
779
+ });
780
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1080
781
  }
1081
- const message = response.message || response.Message || errorCode;
1082
- response.message = message;
1083
- delete response.Message;
1084
- return Promise.reject(Object.assign(new Error(message), response));
1085
782
  };
1086
783
  const deserializeAws_queryCreateTargetGroupCommand = async (output, context) => {
1087
784
  if (output.statusCode >= 300) {
@@ -1108,51 +805,25 @@ const deserializeAws_queryCreateTargetGroupCommandError = async (output, context
1108
805
  switch (errorCode) {
1109
806
  case "DuplicateTargetGroupNameException":
1110
807
  case "com.amazonaws.elasticloadbalancingv2#DuplicateTargetGroupNameException":
1111
- response = {
1112
- ...(await deserializeAws_queryDuplicateTargetGroupNameExceptionResponse(parsedOutput, context)),
1113
- name: errorCode,
1114
- $metadata: deserializeMetadata(output),
1115
- };
1116
- break;
808
+ throw await deserializeAws_queryDuplicateTargetGroupNameExceptionResponse(parsedOutput, context);
1117
809
  case "InvalidConfigurationRequestException":
1118
810
  case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
1119
- response = {
1120
- ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
1121
- name: errorCode,
1122
- $metadata: deserializeMetadata(output),
1123
- };
1124
- break;
811
+ throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
1125
812
  case "TooManyTagsException":
1126
813
  case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
1127
- response = {
1128
- ...(await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)),
1129
- name: errorCode,
1130
- $metadata: deserializeMetadata(output),
1131
- };
1132
- break;
814
+ throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
1133
815
  case "TooManyTargetGroupsException":
1134
816
  case "com.amazonaws.elasticloadbalancingv2#TooManyTargetGroupsException":
1135
- response = {
1136
- ...(await deserializeAws_queryTooManyTargetGroupsExceptionResponse(parsedOutput, context)),
1137
- name: errorCode,
1138
- $metadata: deserializeMetadata(output),
1139
- };
1140
- break;
817
+ throw await deserializeAws_queryTooManyTargetGroupsExceptionResponse(parsedOutput, context);
1141
818
  default:
1142
819
  const parsedBody = parsedOutput.body;
1143
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1144
- response = {
1145
- ...parsedBody.Error,
1146
- name: `${errorCode}`,
1147
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
820
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
821
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1148
822
  $fault: "client",
1149
823
  $metadata: deserializeMetadata(output),
1150
- };
824
+ });
825
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1151
826
  }
1152
- const message = response.message || response.Message || errorCode;
1153
- response.message = message;
1154
- delete response.Message;
1155
- return Promise.reject(Object.assign(new Error(message), response));
1156
827
  };
1157
828
  const deserializeAws_queryDeleteListenerCommand = async (output, context) => {
1158
829
  if (output.statusCode >= 300) {
@@ -1179,35 +850,19 @@ const deserializeAws_queryDeleteListenerCommandError = async (output, context) =
1179
850
  switch (errorCode) {
1180
851
  case "ListenerNotFoundException":
1181
852
  case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
1182
- response = {
1183
- ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
1184
- name: errorCode,
1185
- $metadata: deserializeMetadata(output),
1186
- };
1187
- break;
853
+ throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
1188
854
  case "ResourceInUseException":
1189
855
  case "com.amazonaws.elasticloadbalancingv2#ResourceInUseException":
1190
- response = {
1191
- ...(await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context)),
1192
- name: errorCode,
1193
- $metadata: deserializeMetadata(output),
1194
- };
1195
- break;
856
+ throw await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context);
1196
857
  default:
1197
858
  const parsedBody = parsedOutput.body;
1198
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1199
- response = {
1200
- ...parsedBody.Error,
1201
- name: `${errorCode}`,
1202
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
859
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
860
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1203
861
  $fault: "client",
1204
862
  $metadata: deserializeMetadata(output),
1205
- };
863
+ });
864
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1206
865
  }
1207
- const message = response.message || response.Message || errorCode;
1208
- response.message = message;
1209
- delete response.Message;
1210
- return Promise.reject(Object.assign(new Error(message), response));
1211
866
  };
1212
867
  const deserializeAws_queryDeleteLoadBalancerCommand = async (output, context) => {
1213
868
  if (output.statusCode >= 300) {
@@ -1234,43 +889,22 @@ const deserializeAws_queryDeleteLoadBalancerCommandError = async (output, contex
1234
889
  switch (errorCode) {
1235
890
  case "LoadBalancerNotFoundException":
1236
891
  case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
1237
- response = {
1238
- ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
1239
- name: errorCode,
1240
- $metadata: deserializeMetadata(output),
1241
- };
1242
- break;
892
+ throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
1243
893
  case "OperationNotPermittedException":
1244
894
  case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
1245
- response = {
1246
- ...(await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context)),
1247
- name: errorCode,
1248
- $metadata: deserializeMetadata(output),
1249
- };
1250
- break;
895
+ throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
1251
896
  case "ResourceInUseException":
1252
897
  case "com.amazonaws.elasticloadbalancingv2#ResourceInUseException":
1253
- response = {
1254
- ...(await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context)),
1255
- name: errorCode,
1256
- $metadata: deserializeMetadata(output),
1257
- };
1258
- break;
898
+ throw await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context);
1259
899
  default:
1260
900
  const parsedBody = parsedOutput.body;
1261
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1262
- response = {
1263
- ...parsedBody.Error,
1264
- name: `${errorCode}`,
1265
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
901
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
902
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1266
903
  $fault: "client",
1267
904
  $metadata: deserializeMetadata(output),
1268
- };
905
+ });
906
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1269
907
  }
1270
- const message = response.message || response.Message || errorCode;
1271
- response.message = message;
1272
- delete response.Message;
1273
- return Promise.reject(Object.assign(new Error(message), response));
1274
908
  };
1275
909
  const deserializeAws_queryDeleteRuleCommand = async (output, context) => {
1276
910
  if (output.statusCode >= 300) {
@@ -1297,35 +931,19 @@ const deserializeAws_queryDeleteRuleCommandError = async (output, context) => {
1297
931
  switch (errorCode) {
1298
932
  case "OperationNotPermittedException":
1299
933
  case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
1300
- response = {
1301
- ...(await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context)),
1302
- name: errorCode,
1303
- $metadata: deserializeMetadata(output),
1304
- };
1305
- break;
934
+ throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
1306
935
  case "RuleNotFoundException":
1307
936
  case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
1308
- response = {
1309
- ...(await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context)),
1310
- name: errorCode,
1311
- $metadata: deserializeMetadata(output),
1312
- };
1313
- break;
937
+ throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
1314
938
  default:
1315
939
  const parsedBody = parsedOutput.body;
1316
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1317
- response = {
1318
- ...parsedBody.Error,
1319
- name: `${errorCode}`,
1320
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
940
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
941
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1321
942
  $fault: "client",
1322
943
  $metadata: deserializeMetadata(output),
1323
- };
944
+ });
945
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1324
946
  }
1325
- const message = response.message || response.Message || errorCode;
1326
- response.message = message;
1327
- delete response.Message;
1328
- return Promise.reject(Object.assign(new Error(message), response));
1329
947
  };
1330
948
  const deserializeAws_queryDeleteTargetGroupCommand = async (output, context) => {
1331
949
  if (output.statusCode >= 300) {
@@ -1352,27 +970,16 @@ const deserializeAws_queryDeleteTargetGroupCommandError = async (output, context
1352
970
  switch (errorCode) {
1353
971
  case "ResourceInUseException":
1354
972
  case "com.amazonaws.elasticloadbalancingv2#ResourceInUseException":
1355
- response = {
1356
- ...(await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context)),
1357
- name: errorCode,
1358
- $metadata: deserializeMetadata(output),
1359
- };
1360
- break;
973
+ throw await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context);
1361
974
  default:
1362
975
  const parsedBody = parsedOutput.body;
1363
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1364
- response = {
1365
- ...parsedBody.Error,
1366
- name: `${errorCode}`,
1367
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
976
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
977
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1368
978
  $fault: "client",
1369
979
  $metadata: deserializeMetadata(output),
1370
- };
980
+ });
981
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1371
982
  }
1372
- const message = response.message || response.Message || errorCode;
1373
- response.message = message;
1374
- delete response.Message;
1375
- return Promise.reject(Object.assign(new Error(message), response));
1376
983
  };
1377
984
  const deserializeAws_queryDeregisterTargetsCommand = async (output, context) => {
1378
985
  if (output.statusCode >= 300) {
@@ -1399,35 +1006,19 @@ const deserializeAws_queryDeregisterTargetsCommandError = async (output, context
1399
1006
  switch (errorCode) {
1400
1007
  case "InvalidTargetException":
1401
1008
  case "com.amazonaws.elasticloadbalancingv2#InvalidTargetException":
1402
- response = {
1403
- ...(await deserializeAws_queryInvalidTargetExceptionResponse(parsedOutput, context)),
1404
- name: errorCode,
1405
- $metadata: deserializeMetadata(output),
1406
- };
1407
- break;
1009
+ throw await deserializeAws_queryInvalidTargetExceptionResponse(parsedOutput, context);
1408
1010
  case "TargetGroupNotFoundException":
1409
1011
  case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
1410
- response = {
1411
- ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
1412
- name: errorCode,
1413
- $metadata: deserializeMetadata(output),
1414
- };
1415
- break;
1012
+ throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
1416
1013
  default:
1417
1014
  const parsedBody = parsedOutput.body;
1418
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1419
- response = {
1420
- ...parsedBody.Error,
1421
- name: `${errorCode}`,
1422
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1015
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1016
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1423
1017
  $fault: "client",
1424
1018
  $metadata: deserializeMetadata(output),
1425
- };
1019
+ });
1020
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1426
1021
  }
1427
- const message = response.message || response.Message || errorCode;
1428
- response.message = message;
1429
- delete response.Message;
1430
- return Promise.reject(Object.assign(new Error(message), response));
1431
1022
  };
1432
1023
  const deserializeAws_queryDescribeAccountLimitsCommand = async (output, context) => {
1433
1024
  if (output.statusCode >= 300) {
@@ -1454,19 +1045,13 @@ const deserializeAws_queryDescribeAccountLimitsCommandError = async (output, con
1454
1045
  switch (errorCode) {
1455
1046
  default:
1456
1047
  const parsedBody = parsedOutput.body;
1457
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1458
- response = {
1459
- ...parsedBody.Error,
1460
- name: `${errorCode}`,
1461
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1048
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1049
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1462
1050
  $fault: "client",
1463
1051
  $metadata: deserializeMetadata(output),
1464
- };
1052
+ });
1053
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1465
1054
  }
1466
- const message = response.message || response.Message || errorCode;
1467
- response.message = message;
1468
- delete response.Message;
1469
- return Promise.reject(Object.assign(new Error(message), response));
1470
1055
  };
1471
1056
  const deserializeAws_queryDescribeListenerCertificatesCommand = async (output, context) => {
1472
1057
  if (output.statusCode >= 300) {
@@ -1493,27 +1078,16 @@ const deserializeAws_queryDescribeListenerCertificatesCommandError = async (outp
1493
1078
  switch (errorCode) {
1494
1079
  case "ListenerNotFoundException":
1495
1080
  case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
1496
- response = {
1497
- ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
1498
- name: errorCode,
1499
- $metadata: deserializeMetadata(output),
1500
- };
1501
- break;
1081
+ throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
1502
1082
  default:
1503
1083
  const parsedBody = parsedOutput.body;
1504
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1505
- response = {
1506
- ...parsedBody.Error,
1507
- name: `${errorCode}`,
1508
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1084
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1085
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1509
1086
  $fault: "client",
1510
1087
  $metadata: deserializeMetadata(output),
1511
- };
1088
+ });
1089
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1512
1090
  }
1513
- const message = response.message || response.Message || errorCode;
1514
- response.message = message;
1515
- delete response.Message;
1516
- return Promise.reject(Object.assign(new Error(message), response));
1517
1091
  };
1518
1092
  const deserializeAws_queryDescribeListenersCommand = async (output, context) => {
1519
1093
  if (output.statusCode >= 300) {
@@ -1540,43 +1114,22 @@ const deserializeAws_queryDescribeListenersCommandError = async (output, context
1540
1114
  switch (errorCode) {
1541
1115
  case "ListenerNotFoundException":
1542
1116
  case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
1543
- response = {
1544
- ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
1545
- name: errorCode,
1546
- $metadata: deserializeMetadata(output),
1547
- };
1548
- break;
1117
+ throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
1549
1118
  case "LoadBalancerNotFoundException":
1550
1119
  case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
1551
- response = {
1552
- ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
1553
- name: errorCode,
1554
- $metadata: deserializeMetadata(output),
1555
- };
1556
- break;
1120
+ throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
1557
1121
  case "UnsupportedProtocolException":
1558
1122
  case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
1559
- response = {
1560
- ...(await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)),
1561
- name: errorCode,
1562
- $metadata: deserializeMetadata(output),
1563
- };
1564
- break;
1123
+ throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
1565
1124
  default:
1566
1125
  const parsedBody = parsedOutput.body;
1567
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1568
- response = {
1569
- ...parsedBody.Error,
1570
- name: `${errorCode}`,
1571
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1126
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1127
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1572
1128
  $fault: "client",
1573
1129
  $metadata: deserializeMetadata(output),
1574
- };
1130
+ });
1131
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1575
1132
  }
1576
- const message = response.message || response.Message || errorCode;
1577
- response.message = message;
1578
- delete response.Message;
1579
- return Promise.reject(Object.assign(new Error(message), response));
1580
1133
  };
1581
1134
  const deserializeAws_queryDescribeLoadBalancerAttributesCommand = async (output, context) => {
1582
1135
  if (output.statusCode >= 300) {
@@ -1603,27 +1156,16 @@ const deserializeAws_queryDescribeLoadBalancerAttributesCommandError = async (ou
1603
1156
  switch (errorCode) {
1604
1157
  case "LoadBalancerNotFoundException":
1605
1158
  case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
1606
- response = {
1607
- ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
1608
- name: errorCode,
1609
- $metadata: deserializeMetadata(output),
1610
- };
1611
- break;
1159
+ throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
1612
1160
  default:
1613
1161
  const parsedBody = parsedOutput.body;
1614
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1615
- response = {
1616
- ...parsedBody.Error,
1617
- name: `${errorCode}`,
1618
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1162
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1163
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1619
1164
  $fault: "client",
1620
1165
  $metadata: deserializeMetadata(output),
1621
- };
1166
+ });
1167
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1622
1168
  }
1623
- const message = response.message || response.Message || errorCode;
1624
- response.message = message;
1625
- delete response.Message;
1626
- return Promise.reject(Object.assign(new Error(message), response));
1627
1169
  };
1628
1170
  const deserializeAws_queryDescribeLoadBalancersCommand = async (output, context) => {
1629
1171
  if (output.statusCode >= 300) {
@@ -1650,27 +1192,16 @@ const deserializeAws_queryDescribeLoadBalancersCommandError = async (output, con
1650
1192
  switch (errorCode) {
1651
1193
  case "LoadBalancerNotFoundException":
1652
1194
  case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
1653
- response = {
1654
- ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
1655
- name: errorCode,
1656
- $metadata: deserializeMetadata(output),
1657
- };
1658
- break;
1195
+ throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
1659
1196
  default:
1660
1197
  const parsedBody = parsedOutput.body;
1661
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1662
- response = {
1663
- ...parsedBody.Error,
1664
- name: `${errorCode}`,
1665
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1198
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1199
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1666
1200
  $fault: "client",
1667
1201
  $metadata: deserializeMetadata(output),
1668
- };
1202
+ });
1203
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1669
1204
  }
1670
- const message = response.message || response.Message || errorCode;
1671
- response.message = message;
1672
- delete response.Message;
1673
- return Promise.reject(Object.assign(new Error(message), response));
1674
1205
  };
1675
1206
  const deserializeAws_queryDescribeRulesCommand = async (output, context) => {
1676
1207
  if (output.statusCode >= 300) {
@@ -1697,43 +1228,22 @@ const deserializeAws_queryDescribeRulesCommandError = async (output, context) =>
1697
1228
  switch (errorCode) {
1698
1229
  case "ListenerNotFoundException":
1699
1230
  case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
1700
- response = {
1701
- ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
1702
- name: errorCode,
1703
- $metadata: deserializeMetadata(output),
1704
- };
1705
- break;
1231
+ throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
1706
1232
  case "RuleNotFoundException":
1707
1233
  case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
1708
- response = {
1709
- ...(await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context)),
1710
- name: errorCode,
1711
- $metadata: deserializeMetadata(output),
1712
- };
1713
- break;
1234
+ throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
1714
1235
  case "UnsupportedProtocolException":
1715
1236
  case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
1716
- response = {
1717
- ...(await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)),
1718
- name: errorCode,
1719
- $metadata: deserializeMetadata(output),
1720
- };
1721
- break;
1237
+ throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
1722
1238
  default:
1723
1239
  const parsedBody = parsedOutput.body;
1724
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1725
- response = {
1726
- ...parsedBody.Error,
1727
- name: `${errorCode}`,
1728
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1240
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1241
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1729
1242
  $fault: "client",
1730
1243
  $metadata: deserializeMetadata(output),
1731
- };
1244
+ });
1245
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1732
1246
  }
1733
- const message = response.message || response.Message || errorCode;
1734
- response.message = message;
1735
- delete response.Message;
1736
- return Promise.reject(Object.assign(new Error(message), response));
1737
1247
  };
1738
1248
  const deserializeAws_queryDescribeSSLPoliciesCommand = async (output, context) => {
1739
1249
  if (output.statusCode >= 300) {
@@ -1760,27 +1270,16 @@ const deserializeAws_queryDescribeSSLPoliciesCommandError = async (output, conte
1760
1270
  switch (errorCode) {
1761
1271
  case "SSLPolicyNotFoundException":
1762
1272
  case "com.amazonaws.elasticloadbalancingv2#SSLPolicyNotFoundException":
1763
- response = {
1764
- ...(await deserializeAws_querySSLPolicyNotFoundExceptionResponse(parsedOutput, context)),
1765
- name: errorCode,
1766
- $metadata: deserializeMetadata(output),
1767
- };
1768
- break;
1273
+ throw await deserializeAws_querySSLPolicyNotFoundExceptionResponse(parsedOutput, context);
1769
1274
  default:
1770
1275
  const parsedBody = parsedOutput.body;
1771
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1772
- response = {
1773
- ...parsedBody.Error,
1774
- name: `${errorCode}`,
1775
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1276
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1277
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1776
1278
  $fault: "client",
1777
1279
  $metadata: deserializeMetadata(output),
1778
- };
1280
+ });
1281
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1779
1282
  }
1780
- const message = response.message || response.Message || errorCode;
1781
- response.message = message;
1782
- delete response.Message;
1783
- return Promise.reject(Object.assign(new Error(message), response));
1784
1283
  };
1785
1284
  const deserializeAws_queryDescribeTagsCommand = async (output, context) => {
1786
1285
  if (output.statusCode >= 300) {
@@ -1807,51 +1306,25 @@ const deserializeAws_queryDescribeTagsCommandError = async (output, context) =>
1807
1306
  switch (errorCode) {
1808
1307
  case "ListenerNotFoundException":
1809
1308
  case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
1810
- response = {
1811
- ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
1812
- name: errorCode,
1813
- $metadata: deserializeMetadata(output),
1814
- };
1815
- break;
1309
+ throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
1816
1310
  case "LoadBalancerNotFoundException":
1817
1311
  case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
1818
- response = {
1819
- ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
1820
- name: errorCode,
1821
- $metadata: deserializeMetadata(output),
1822
- };
1823
- break;
1312
+ throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
1824
1313
  case "RuleNotFoundException":
1825
1314
  case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
1826
- response = {
1827
- ...(await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context)),
1828
- name: errorCode,
1829
- $metadata: deserializeMetadata(output),
1830
- };
1831
- break;
1315
+ throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
1832
1316
  case "TargetGroupNotFoundException":
1833
1317
  case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
1834
- response = {
1835
- ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
1836
- name: errorCode,
1837
- $metadata: deserializeMetadata(output),
1838
- };
1839
- break;
1318
+ throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
1840
1319
  default:
1841
1320
  const parsedBody = parsedOutput.body;
1842
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1843
- response = {
1844
- ...parsedBody.Error,
1845
- name: `${errorCode}`,
1846
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1321
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1322
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1847
1323
  $fault: "client",
1848
1324
  $metadata: deserializeMetadata(output),
1849
- };
1325
+ });
1326
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1850
1327
  }
1851
- const message = response.message || response.Message || errorCode;
1852
- response.message = message;
1853
- delete response.Message;
1854
- return Promise.reject(Object.assign(new Error(message), response));
1855
1328
  };
1856
1329
  const deserializeAws_queryDescribeTargetGroupAttributesCommand = async (output, context) => {
1857
1330
  if (output.statusCode >= 300) {
@@ -1878,27 +1351,16 @@ const deserializeAws_queryDescribeTargetGroupAttributesCommandError = async (out
1878
1351
  switch (errorCode) {
1879
1352
  case "TargetGroupNotFoundException":
1880
1353
  case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
1881
- response = {
1882
- ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
1883
- name: errorCode,
1884
- $metadata: deserializeMetadata(output),
1885
- };
1886
- break;
1354
+ throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
1887
1355
  default:
1888
1356
  const parsedBody = parsedOutput.body;
1889
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1890
- response = {
1891
- ...parsedBody.Error,
1892
- name: `${errorCode}`,
1893
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1357
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1358
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1894
1359
  $fault: "client",
1895
1360
  $metadata: deserializeMetadata(output),
1896
- };
1361
+ });
1362
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1897
1363
  }
1898
- const message = response.message || response.Message || errorCode;
1899
- response.message = message;
1900
- delete response.Message;
1901
- return Promise.reject(Object.assign(new Error(message), response));
1902
1364
  };
1903
1365
  const deserializeAws_queryDescribeTargetGroupsCommand = async (output, context) => {
1904
1366
  if (output.statusCode >= 300) {
@@ -1925,35 +1387,19 @@ const deserializeAws_queryDescribeTargetGroupsCommandError = async (output, cont
1925
1387
  switch (errorCode) {
1926
1388
  case "LoadBalancerNotFoundException":
1927
1389
  case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
1928
- response = {
1929
- ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
1930
- name: errorCode,
1931
- $metadata: deserializeMetadata(output),
1932
- };
1933
- break;
1390
+ throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
1934
1391
  case "TargetGroupNotFoundException":
1935
1392
  case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
1936
- response = {
1937
- ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
1938
- name: errorCode,
1939
- $metadata: deserializeMetadata(output),
1940
- };
1941
- break;
1393
+ throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
1942
1394
  default:
1943
1395
  const parsedBody = parsedOutput.body;
1944
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1945
- response = {
1946
- ...parsedBody.Error,
1947
- name: `${errorCode}`,
1948
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1396
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1397
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1949
1398
  $fault: "client",
1950
1399
  $metadata: deserializeMetadata(output),
1951
- };
1400
+ });
1401
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1952
1402
  }
1953
- const message = response.message || response.Message || errorCode;
1954
- response.message = message;
1955
- delete response.Message;
1956
- return Promise.reject(Object.assign(new Error(message), response));
1957
1403
  };
1958
1404
  const deserializeAws_queryDescribeTargetHealthCommand = async (output, context) => {
1959
1405
  if (output.statusCode >= 300) {
@@ -1980,43 +1426,22 @@ const deserializeAws_queryDescribeTargetHealthCommandError = async (output, cont
1980
1426
  switch (errorCode) {
1981
1427
  case "HealthUnavailableException":
1982
1428
  case "com.amazonaws.elasticloadbalancingv2#HealthUnavailableException":
1983
- response = {
1984
- ...(await deserializeAws_queryHealthUnavailableExceptionResponse(parsedOutput, context)),
1985
- name: errorCode,
1986
- $metadata: deserializeMetadata(output),
1987
- };
1988
- break;
1429
+ throw await deserializeAws_queryHealthUnavailableExceptionResponse(parsedOutput, context);
1989
1430
  case "InvalidTargetException":
1990
1431
  case "com.amazonaws.elasticloadbalancingv2#InvalidTargetException":
1991
- response = {
1992
- ...(await deserializeAws_queryInvalidTargetExceptionResponse(parsedOutput, context)),
1993
- name: errorCode,
1994
- $metadata: deserializeMetadata(output),
1995
- };
1996
- break;
1432
+ throw await deserializeAws_queryInvalidTargetExceptionResponse(parsedOutput, context);
1997
1433
  case "TargetGroupNotFoundException":
1998
1434
  case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
1999
- response = {
2000
- ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
2001
- name: errorCode,
2002
- $metadata: deserializeMetadata(output),
2003
- };
2004
- break;
1435
+ throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
2005
1436
  default:
2006
1437
  const parsedBody = parsedOutput.body;
2007
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2008
- response = {
2009
- ...parsedBody.Error,
2010
- name: `${errorCode}`,
2011
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1438
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1439
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2012
1440
  $fault: "client",
2013
1441
  $metadata: deserializeMetadata(output),
2014
- };
1442
+ });
1443
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2015
1444
  }
2016
- const message = response.message || response.Message || errorCode;
2017
- response.message = message;
2018
- delete response.Message;
2019
- return Promise.reject(Object.assign(new Error(message), response));
2020
1445
  };
2021
1446
  const deserializeAws_queryModifyListenerCommand = async (output, context) => {
2022
1447
  if (output.statusCode >= 300) {
@@ -2043,155 +1468,64 @@ const deserializeAws_queryModifyListenerCommandError = async (output, context) =
2043
1468
  switch (errorCode) {
2044
1469
  case "ALPNPolicyNotSupportedException":
2045
1470
  case "com.amazonaws.elasticloadbalancingv2#ALPNPolicyNotSupportedException":
2046
- response = {
2047
- ...(await deserializeAws_queryALPNPolicyNotSupportedExceptionResponse(parsedOutput, context)),
2048
- name: errorCode,
2049
- $metadata: deserializeMetadata(output),
2050
- };
2051
- break;
1471
+ throw await deserializeAws_queryALPNPolicyNotSupportedExceptionResponse(parsedOutput, context);
2052
1472
  case "CertificateNotFoundException":
2053
1473
  case "com.amazonaws.elasticloadbalancingv2#CertificateNotFoundException":
2054
- response = {
2055
- ...(await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context)),
2056
- name: errorCode,
2057
- $metadata: deserializeMetadata(output),
2058
- };
2059
- break;
1474
+ throw await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context);
2060
1475
  case "DuplicateListenerException":
2061
1476
  case "com.amazonaws.elasticloadbalancingv2#DuplicateListenerException":
2062
- response = {
2063
- ...(await deserializeAws_queryDuplicateListenerExceptionResponse(parsedOutput, context)),
2064
- name: errorCode,
2065
- $metadata: deserializeMetadata(output),
2066
- };
2067
- break;
1477
+ throw await deserializeAws_queryDuplicateListenerExceptionResponse(parsedOutput, context);
2068
1478
  case "IncompatibleProtocolsException":
2069
1479
  case "com.amazonaws.elasticloadbalancingv2#IncompatibleProtocolsException":
2070
- response = {
2071
- ...(await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context)),
2072
- name: errorCode,
2073
- $metadata: deserializeMetadata(output),
2074
- };
2075
- break;
1480
+ throw await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context);
2076
1481
  case "InvalidConfigurationRequestException":
2077
1482
  case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
2078
- response = {
2079
- ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
2080
- name: errorCode,
2081
- $metadata: deserializeMetadata(output),
2082
- };
2083
- break;
1483
+ throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
2084
1484
  case "InvalidLoadBalancerActionException":
2085
1485
  case "com.amazonaws.elasticloadbalancingv2#InvalidLoadBalancerActionException":
2086
- response = {
2087
- ...(await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context)),
2088
- name: errorCode,
2089
- $metadata: deserializeMetadata(output),
2090
- };
2091
- break;
1486
+ throw await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context);
2092
1487
  case "ListenerNotFoundException":
2093
1488
  case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
2094
- response = {
2095
- ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
2096
- name: errorCode,
2097
- $metadata: deserializeMetadata(output),
2098
- };
2099
- break;
1489
+ throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
2100
1490
  case "SSLPolicyNotFoundException":
2101
1491
  case "com.amazonaws.elasticloadbalancingv2#SSLPolicyNotFoundException":
2102
- response = {
2103
- ...(await deserializeAws_querySSLPolicyNotFoundExceptionResponse(parsedOutput, context)),
2104
- name: errorCode,
2105
- $metadata: deserializeMetadata(output),
2106
- };
2107
- break;
1492
+ throw await deserializeAws_querySSLPolicyNotFoundExceptionResponse(parsedOutput, context);
2108
1493
  case "TargetGroupAssociationLimitException":
2109
1494
  case "com.amazonaws.elasticloadbalancingv2#TargetGroupAssociationLimitException":
2110
- response = {
2111
- ...(await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context)),
2112
- name: errorCode,
2113
- $metadata: deserializeMetadata(output),
2114
- };
2115
- break;
1495
+ throw await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context);
2116
1496
  case "TargetGroupNotFoundException":
2117
1497
  case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
2118
- response = {
2119
- ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
2120
- name: errorCode,
2121
- $metadata: deserializeMetadata(output),
2122
- };
2123
- break;
1498
+ throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
2124
1499
  case "TooManyActionsException":
2125
1500
  case "com.amazonaws.elasticloadbalancingv2#TooManyActionsException":
2126
- response = {
2127
- ...(await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context)),
2128
- name: errorCode,
2129
- $metadata: deserializeMetadata(output),
2130
- };
2131
- break;
1501
+ throw await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context);
2132
1502
  case "TooManyCertificatesException":
2133
1503
  case "com.amazonaws.elasticloadbalancingv2#TooManyCertificatesException":
2134
- response = {
2135
- ...(await deserializeAws_queryTooManyCertificatesExceptionResponse(parsedOutput, context)),
2136
- name: errorCode,
2137
- $metadata: deserializeMetadata(output),
2138
- };
2139
- break;
1504
+ throw await deserializeAws_queryTooManyCertificatesExceptionResponse(parsedOutput, context);
2140
1505
  case "TooManyListenersException":
2141
1506
  case "com.amazonaws.elasticloadbalancingv2#TooManyListenersException":
2142
- response = {
2143
- ...(await deserializeAws_queryTooManyListenersExceptionResponse(parsedOutput, context)),
2144
- name: errorCode,
2145
- $metadata: deserializeMetadata(output),
2146
- };
2147
- break;
1507
+ throw await deserializeAws_queryTooManyListenersExceptionResponse(parsedOutput, context);
2148
1508
  case "TooManyRegistrationsForTargetIdException":
2149
1509
  case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
2150
- response = {
2151
- ...(await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context)),
2152
- name: errorCode,
2153
- $metadata: deserializeMetadata(output),
2154
- };
2155
- break;
1510
+ throw await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context);
2156
1511
  case "TooManyTargetsException":
2157
1512
  case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
2158
- response = {
2159
- ...(await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context)),
2160
- name: errorCode,
2161
- $metadata: deserializeMetadata(output),
2162
- };
2163
- break;
1513
+ throw await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context);
2164
1514
  case "TooManyUniqueTargetGroupsPerLoadBalancerException":
2165
1515
  case "com.amazonaws.elasticloadbalancingv2#TooManyUniqueTargetGroupsPerLoadBalancerException":
2166
- response = {
2167
- ...(await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context)),
2168
- name: errorCode,
2169
- $metadata: deserializeMetadata(output),
2170
- };
2171
- break;
1516
+ throw await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context);
2172
1517
  case "UnsupportedProtocolException":
2173
1518
  case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
2174
- response = {
2175
- ...(await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)),
2176
- name: errorCode,
2177
- $metadata: deserializeMetadata(output),
2178
- };
2179
- break;
1519
+ throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
2180
1520
  default:
2181
1521
  const parsedBody = parsedOutput.body;
2182
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2183
- response = {
2184
- ...parsedBody.Error,
2185
- name: `${errorCode}`,
2186
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1522
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1523
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2187
1524
  $fault: "client",
2188
1525
  $metadata: deserializeMetadata(output),
2189
- };
1526
+ });
1527
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2190
1528
  }
2191
- const message = response.message || response.Message || errorCode;
2192
- response.message = message;
2193
- delete response.Message;
2194
- return Promise.reject(Object.assign(new Error(message), response));
2195
1529
  };
2196
1530
  const deserializeAws_queryModifyLoadBalancerAttributesCommand = async (output, context) => {
2197
1531
  if (output.statusCode >= 300) {
@@ -2218,35 +1552,19 @@ const deserializeAws_queryModifyLoadBalancerAttributesCommandError = async (outp
2218
1552
  switch (errorCode) {
2219
1553
  case "InvalidConfigurationRequestException":
2220
1554
  case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
2221
- response = {
2222
- ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
2223
- name: errorCode,
2224
- $metadata: deserializeMetadata(output),
2225
- };
2226
- break;
1555
+ throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
2227
1556
  case "LoadBalancerNotFoundException":
2228
1557
  case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
2229
- response = {
2230
- ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
2231
- name: errorCode,
2232
- $metadata: deserializeMetadata(output),
2233
- };
2234
- break;
1558
+ throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
2235
1559
  default:
2236
1560
  const parsedBody = parsedOutput.body;
2237
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2238
- response = {
2239
- ...parsedBody.Error,
2240
- name: `${errorCode}`,
2241
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1561
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1562
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2242
1563
  $fault: "client",
2243
1564
  $metadata: deserializeMetadata(output),
2244
- };
1565
+ });
1566
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2245
1567
  }
2246
- const message = response.message || response.Message || errorCode;
2247
- response.message = message;
2248
- delete response.Message;
2249
- return Promise.reject(Object.assign(new Error(message), response));
2250
1568
  };
2251
1569
  const deserializeAws_queryModifyRuleCommand = async (output, context) => {
2252
1570
  if (output.statusCode >= 300) {
@@ -2273,107 +1591,46 @@ const deserializeAws_queryModifyRuleCommandError = async (output, context) => {
2273
1591
  switch (errorCode) {
2274
1592
  case "IncompatibleProtocolsException":
2275
1593
  case "com.amazonaws.elasticloadbalancingv2#IncompatibleProtocolsException":
2276
- response = {
2277
- ...(await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context)),
2278
- name: errorCode,
2279
- $metadata: deserializeMetadata(output),
2280
- };
2281
- break;
1594
+ throw await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context);
2282
1595
  case "InvalidLoadBalancerActionException":
2283
1596
  case "com.amazonaws.elasticloadbalancingv2#InvalidLoadBalancerActionException":
2284
- response = {
2285
- ...(await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context)),
2286
- name: errorCode,
2287
- $metadata: deserializeMetadata(output),
2288
- };
2289
- break;
1597
+ throw await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context);
2290
1598
  case "OperationNotPermittedException":
2291
1599
  case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
2292
- response = {
2293
- ...(await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context)),
2294
- name: errorCode,
2295
- $metadata: deserializeMetadata(output),
2296
- };
2297
- break;
1600
+ throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
2298
1601
  case "RuleNotFoundException":
2299
1602
  case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
2300
- response = {
2301
- ...(await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context)),
2302
- name: errorCode,
2303
- $metadata: deserializeMetadata(output),
2304
- };
2305
- break;
1603
+ throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
2306
1604
  case "TargetGroupAssociationLimitException":
2307
1605
  case "com.amazonaws.elasticloadbalancingv2#TargetGroupAssociationLimitException":
2308
- response = {
2309
- ...(await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context)),
2310
- name: errorCode,
2311
- $metadata: deserializeMetadata(output),
2312
- };
2313
- break;
1606
+ throw await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context);
2314
1607
  case "TargetGroupNotFoundException":
2315
1608
  case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
2316
- response = {
2317
- ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
2318
- name: errorCode,
2319
- $metadata: deserializeMetadata(output),
2320
- };
2321
- break;
1609
+ throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
2322
1610
  case "TooManyActionsException":
2323
1611
  case "com.amazonaws.elasticloadbalancingv2#TooManyActionsException":
2324
- response = {
2325
- ...(await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context)),
2326
- name: errorCode,
2327
- $metadata: deserializeMetadata(output),
2328
- };
2329
- break;
1612
+ throw await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context);
2330
1613
  case "TooManyRegistrationsForTargetIdException":
2331
1614
  case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
2332
- response = {
2333
- ...(await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context)),
2334
- name: errorCode,
2335
- $metadata: deserializeMetadata(output),
2336
- };
2337
- break;
1615
+ throw await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context);
2338
1616
  case "TooManyTargetsException":
2339
1617
  case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
2340
- response = {
2341
- ...(await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context)),
2342
- name: errorCode,
2343
- $metadata: deserializeMetadata(output),
2344
- };
2345
- break;
1618
+ throw await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context);
2346
1619
  case "TooManyUniqueTargetGroupsPerLoadBalancerException":
2347
1620
  case "com.amazonaws.elasticloadbalancingv2#TooManyUniqueTargetGroupsPerLoadBalancerException":
2348
- response = {
2349
- ...(await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context)),
2350
- name: errorCode,
2351
- $metadata: deserializeMetadata(output),
2352
- };
2353
- break;
1621
+ throw await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context);
2354
1622
  case "UnsupportedProtocolException":
2355
1623
  case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
2356
- response = {
2357
- ...(await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)),
2358
- name: errorCode,
2359
- $metadata: deserializeMetadata(output),
2360
- };
2361
- break;
1624
+ throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
2362
1625
  default:
2363
1626
  const parsedBody = parsedOutput.body;
2364
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2365
- response = {
2366
- ...parsedBody.Error,
2367
- name: `${errorCode}`,
2368
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1627
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1628
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2369
1629
  $fault: "client",
2370
1630
  $metadata: deserializeMetadata(output),
2371
- };
1631
+ });
1632
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2372
1633
  }
2373
- const message = response.message || response.Message || errorCode;
2374
- response.message = message;
2375
- delete response.Message;
2376
- return Promise.reject(Object.assign(new Error(message), response));
2377
1634
  };
2378
1635
  const deserializeAws_queryModifyTargetGroupCommand = async (output, context) => {
2379
1636
  if (output.statusCode >= 300) {
@@ -2400,35 +1657,19 @@ const deserializeAws_queryModifyTargetGroupCommandError = async (output, context
2400
1657
  switch (errorCode) {
2401
1658
  case "InvalidConfigurationRequestException":
2402
1659
  case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
2403
- response = {
2404
- ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
2405
- name: errorCode,
2406
- $metadata: deserializeMetadata(output),
2407
- };
2408
- break;
1660
+ throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
2409
1661
  case "TargetGroupNotFoundException":
2410
1662
  case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
2411
- response = {
2412
- ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
2413
- name: errorCode,
2414
- $metadata: deserializeMetadata(output),
2415
- };
2416
- break;
1663
+ throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
2417
1664
  default:
2418
1665
  const parsedBody = parsedOutput.body;
2419
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2420
- response = {
2421
- ...parsedBody.Error,
2422
- name: `${errorCode}`,
2423
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1666
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1667
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2424
1668
  $fault: "client",
2425
1669
  $metadata: deserializeMetadata(output),
2426
- };
1670
+ });
1671
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2427
1672
  }
2428
- const message = response.message || response.Message || errorCode;
2429
- response.message = message;
2430
- delete response.Message;
2431
- return Promise.reject(Object.assign(new Error(message), response));
2432
1673
  };
2433
1674
  const deserializeAws_queryModifyTargetGroupAttributesCommand = async (output, context) => {
2434
1675
  if (output.statusCode >= 300) {
@@ -2455,35 +1696,19 @@ const deserializeAws_queryModifyTargetGroupAttributesCommandError = async (outpu
2455
1696
  switch (errorCode) {
2456
1697
  case "InvalidConfigurationRequestException":
2457
1698
  case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
2458
- response = {
2459
- ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
2460
- name: errorCode,
2461
- $metadata: deserializeMetadata(output),
2462
- };
2463
- break;
1699
+ throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
2464
1700
  case "TargetGroupNotFoundException":
2465
1701
  case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
2466
- response = {
2467
- ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
2468
- name: errorCode,
2469
- $metadata: deserializeMetadata(output),
2470
- };
2471
- break;
1702
+ throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
2472
1703
  default:
2473
1704
  const parsedBody = parsedOutput.body;
2474
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2475
- response = {
2476
- ...parsedBody.Error,
2477
- name: `${errorCode}`,
2478
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1705
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1706
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2479
1707
  $fault: "client",
2480
1708
  $metadata: deserializeMetadata(output),
2481
- };
1709
+ });
1710
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2482
1711
  }
2483
- const message = response.message || response.Message || errorCode;
2484
- response.message = message;
2485
- delete response.Message;
2486
- return Promise.reject(Object.assign(new Error(message), response));
2487
1712
  };
2488
1713
  const deserializeAws_queryRegisterTargetsCommand = async (output, context) => {
2489
1714
  if (output.statusCode >= 300) {
@@ -2510,51 +1735,25 @@ const deserializeAws_queryRegisterTargetsCommandError = async (output, context)
2510
1735
  switch (errorCode) {
2511
1736
  case "InvalidTargetException":
2512
1737
  case "com.amazonaws.elasticloadbalancingv2#InvalidTargetException":
2513
- response = {
2514
- ...(await deserializeAws_queryInvalidTargetExceptionResponse(parsedOutput, context)),
2515
- name: errorCode,
2516
- $metadata: deserializeMetadata(output),
2517
- };
2518
- break;
1738
+ throw await deserializeAws_queryInvalidTargetExceptionResponse(parsedOutput, context);
2519
1739
  case "TargetGroupNotFoundException":
2520
1740
  case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
2521
- response = {
2522
- ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
2523
- name: errorCode,
2524
- $metadata: deserializeMetadata(output),
2525
- };
2526
- break;
1741
+ throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
2527
1742
  case "TooManyRegistrationsForTargetIdException":
2528
1743
  case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
2529
- response = {
2530
- ...(await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context)),
2531
- name: errorCode,
2532
- $metadata: deserializeMetadata(output),
2533
- };
2534
- break;
1744
+ throw await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context);
2535
1745
  case "TooManyTargetsException":
2536
1746
  case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
2537
- response = {
2538
- ...(await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context)),
2539
- name: errorCode,
2540
- $metadata: deserializeMetadata(output),
2541
- };
2542
- break;
1747
+ throw await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context);
2543
1748
  default:
2544
1749
  const parsedBody = parsedOutput.body;
2545
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2546
- response = {
2547
- ...parsedBody.Error,
2548
- name: `${errorCode}`,
2549
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1750
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1751
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2550
1752
  $fault: "client",
2551
1753
  $metadata: deserializeMetadata(output),
2552
- };
1754
+ });
1755
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2553
1756
  }
2554
- const message = response.message || response.Message || errorCode;
2555
- response.message = message;
2556
- delete response.Message;
2557
- return Promise.reject(Object.assign(new Error(message), response));
2558
1757
  };
2559
1758
  const deserializeAws_queryRemoveListenerCertificatesCommand = async (output, context) => {
2560
1759
  if (output.statusCode >= 300) {
@@ -2581,35 +1780,19 @@ const deserializeAws_queryRemoveListenerCertificatesCommandError = async (output
2581
1780
  switch (errorCode) {
2582
1781
  case "ListenerNotFoundException":
2583
1782
  case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
2584
- response = {
2585
- ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
2586
- name: errorCode,
2587
- $metadata: deserializeMetadata(output),
2588
- };
2589
- break;
1783
+ throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
2590
1784
  case "OperationNotPermittedException":
2591
1785
  case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
2592
- response = {
2593
- ...(await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context)),
2594
- name: errorCode,
2595
- $metadata: deserializeMetadata(output),
2596
- };
2597
- break;
1786
+ throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
2598
1787
  default:
2599
1788
  const parsedBody = parsedOutput.body;
2600
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2601
- response = {
2602
- ...parsedBody.Error,
2603
- name: `${errorCode}`,
2604
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1789
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1790
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2605
1791
  $fault: "client",
2606
1792
  $metadata: deserializeMetadata(output),
2607
- };
1793
+ });
1794
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2608
1795
  }
2609
- const message = response.message || response.Message || errorCode;
2610
- response.message = message;
2611
- delete response.Message;
2612
- return Promise.reject(Object.assign(new Error(message), response));
2613
1796
  };
2614
1797
  const deserializeAws_queryRemoveTagsCommand = async (output, context) => {
2615
1798
  if (output.statusCode >= 300) {
@@ -2636,59 +1819,28 @@ const deserializeAws_queryRemoveTagsCommandError = async (output, context) => {
2636
1819
  switch (errorCode) {
2637
1820
  case "ListenerNotFoundException":
2638
1821
  case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
2639
- response = {
2640
- ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
2641
- name: errorCode,
2642
- $metadata: deserializeMetadata(output),
2643
- };
2644
- break;
1822
+ throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
2645
1823
  case "LoadBalancerNotFoundException":
2646
1824
  case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
2647
- response = {
2648
- ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
2649
- name: errorCode,
2650
- $metadata: deserializeMetadata(output),
2651
- };
2652
- break;
1825
+ throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
2653
1826
  case "RuleNotFoundException":
2654
1827
  case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
2655
- response = {
2656
- ...(await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context)),
2657
- name: errorCode,
2658
- $metadata: deserializeMetadata(output),
2659
- };
2660
- break;
1828
+ throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
2661
1829
  case "TargetGroupNotFoundException":
2662
1830
  case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
2663
- response = {
2664
- ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
2665
- name: errorCode,
2666
- $metadata: deserializeMetadata(output),
2667
- };
2668
- break;
1831
+ throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
2669
1832
  case "TooManyTagsException":
2670
1833
  case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
2671
- response = {
2672
- ...(await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)),
2673
- name: errorCode,
2674
- $metadata: deserializeMetadata(output),
2675
- };
2676
- break;
1834
+ throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
2677
1835
  default:
2678
1836
  const parsedBody = parsedOutput.body;
2679
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2680
- response = {
2681
- ...parsedBody.Error,
2682
- name: `${errorCode}`,
2683
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1837
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1838
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2684
1839
  $fault: "client",
2685
1840
  $metadata: deserializeMetadata(output),
2686
- };
1841
+ });
1842
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2687
1843
  }
2688
- const message = response.message || response.Message || errorCode;
2689
- response.message = message;
2690
- delete response.Message;
2691
- return Promise.reject(Object.assign(new Error(message), response));
2692
1844
  };
2693
1845
  const deserializeAws_querySetIpAddressTypeCommand = async (output, context) => {
2694
1846
  if (output.statusCode >= 300) {
@@ -2715,43 +1867,22 @@ const deserializeAws_querySetIpAddressTypeCommandError = async (output, context)
2715
1867
  switch (errorCode) {
2716
1868
  case "InvalidConfigurationRequestException":
2717
1869
  case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
2718
- response = {
2719
- ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
2720
- name: errorCode,
2721
- $metadata: deserializeMetadata(output),
2722
- };
2723
- break;
1870
+ throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
2724
1871
  case "InvalidSubnetException":
2725
1872
  case "com.amazonaws.elasticloadbalancingv2#InvalidSubnetException":
2726
- response = {
2727
- ...(await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context)),
2728
- name: errorCode,
2729
- $metadata: deserializeMetadata(output),
2730
- };
2731
- break;
1873
+ throw await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context);
2732
1874
  case "LoadBalancerNotFoundException":
2733
1875
  case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
2734
- response = {
2735
- ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
2736
- name: errorCode,
2737
- $metadata: deserializeMetadata(output),
2738
- };
2739
- break;
1876
+ throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
2740
1877
  default:
2741
1878
  const parsedBody = parsedOutput.body;
2742
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2743
- response = {
2744
- ...parsedBody.Error,
2745
- name: `${errorCode}`,
2746
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1879
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1880
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2747
1881
  $fault: "client",
2748
1882
  $metadata: deserializeMetadata(output),
2749
- };
1883
+ });
1884
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2750
1885
  }
2751
- const message = response.message || response.Message || errorCode;
2752
- response.message = message;
2753
- delete response.Message;
2754
- return Promise.reject(Object.assign(new Error(message), response));
2755
1886
  };
2756
1887
  const deserializeAws_querySetRulePrioritiesCommand = async (output, context) => {
2757
1888
  if (output.statusCode >= 300) {
@@ -2778,43 +1909,22 @@ const deserializeAws_querySetRulePrioritiesCommandError = async (output, context
2778
1909
  switch (errorCode) {
2779
1910
  case "OperationNotPermittedException":
2780
1911
  case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
2781
- response = {
2782
- ...(await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context)),
2783
- name: errorCode,
2784
- $metadata: deserializeMetadata(output),
2785
- };
2786
- break;
1912
+ throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
2787
1913
  case "PriorityInUseException":
2788
1914
  case "com.amazonaws.elasticloadbalancingv2#PriorityInUseException":
2789
- response = {
2790
- ...(await deserializeAws_queryPriorityInUseExceptionResponse(parsedOutput, context)),
2791
- name: errorCode,
2792
- $metadata: deserializeMetadata(output),
2793
- };
2794
- break;
1915
+ throw await deserializeAws_queryPriorityInUseExceptionResponse(parsedOutput, context);
2795
1916
  case "RuleNotFoundException":
2796
1917
  case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
2797
- response = {
2798
- ...(await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context)),
2799
- name: errorCode,
2800
- $metadata: deserializeMetadata(output),
2801
- };
2802
- break;
1918
+ throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
2803
1919
  default:
2804
1920
  const parsedBody = parsedOutput.body;
2805
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2806
- response = {
2807
- ...parsedBody.Error,
2808
- name: `${errorCode}`,
2809
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1921
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1922
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2810
1923
  $fault: "client",
2811
1924
  $metadata: deserializeMetadata(output),
2812
- };
1925
+ });
1926
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2813
1927
  }
2814
- const message = response.message || response.Message || errorCode;
2815
- response.message = message;
2816
- delete response.Message;
2817
- return Promise.reject(Object.assign(new Error(message), response));
2818
1928
  };
2819
1929
  const deserializeAws_querySetSecurityGroupsCommand = async (output, context) => {
2820
1930
  if (output.statusCode >= 300) {
@@ -2841,43 +1951,22 @@ const deserializeAws_querySetSecurityGroupsCommandError = async (output, context
2841
1951
  switch (errorCode) {
2842
1952
  case "InvalidConfigurationRequestException":
2843
1953
  case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
2844
- response = {
2845
- ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
2846
- name: errorCode,
2847
- $metadata: deserializeMetadata(output),
2848
- };
2849
- break;
1954
+ throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
2850
1955
  case "InvalidSecurityGroupException":
2851
1956
  case "com.amazonaws.elasticloadbalancingv2#InvalidSecurityGroupException":
2852
- response = {
2853
- ...(await deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context)),
2854
- name: errorCode,
2855
- $metadata: deserializeMetadata(output),
2856
- };
2857
- break;
1957
+ throw await deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context);
2858
1958
  case "LoadBalancerNotFoundException":
2859
1959
  case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
2860
- response = {
2861
- ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
2862
- name: errorCode,
2863
- $metadata: deserializeMetadata(output),
2864
- };
2865
- break;
1960
+ throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
2866
1961
  default:
2867
1962
  const parsedBody = parsedOutput.body;
2868
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2869
- response = {
2870
- ...parsedBody.Error,
2871
- name: `${errorCode}`,
2872
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1963
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
1964
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2873
1965
  $fault: "client",
2874
1966
  $metadata: deserializeMetadata(output),
2875
- };
1967
+ });
1968
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2876
1969
  }
2877
- const message = response.message || response.Message || errorCode;
2878
- response.message = message;
2879
- delete response.Message;
2880
- return Promise.reject(Object.assign(new Error(message), response));
2881
1970
  };
2882
1971
  const deserializeAws_querySetSubnetsCommand = async (output, context) => {
2883
1972
  if (output.statusCode >= 300) {
@@ -2904,474 +1993,364 @@ const deserializeAws_querySetSubnetsCommandError = async (output, context) => {
2904
1993
  switch (errorCode) {
2905
1994
  case "AllocationIdNotFoundException":
2906
1995
  case "com.amazonaws.elasticloadbalancingv2#AllocationIdNotFoundException":
2907
- response = {
2908
- ...(await deserializeAws_queryAllocationIdNotFoundExceptionResponse(parsedOutput, context)),
2909
- name: errorCode,
2910
- $metadata: deserializeMetadata(output),
2911
- };
2912
- break;
1996
+ throw await deserializeAws_queryAllocationIdNotFoundExceptionResponse(parsedOutput, context);
2913
1997
  case "AvailabilityZoneNotSupportedException":
2914
1998
  case "com.amazonaws.elasticloadbalancingv2#AvailabilityZoneNotSupportedException":
2915
- response = {
2916
- ...(await deserializeAws_queryAvailabilityZoneNotSupportedExceptionResponse(parsedOutput, context)),
2917
- name: errorCode,
2918
- $metadata: deserializeMetadata(output),
2919
- };
2920
- break;
1999
+ throw await deserializeAws_queryAvailabilityZoneNotSupportedExceptionResponse(parsedOutput, context);
2921
2000
  case "InvalidConfigurationRequestException":
2922
2001
  case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
2923
- response = {
2924
- ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
2925
- name: errorCode,
2926
- $metadata: deserializeMetadata(output),
2927
- };
2928
- break;
2002
+ throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
2929
2003
  case "InvalidSubnetException":
2930
2004
  case "com.amazonaws.elasticloadbalancingv2#InvalidSubnetException":
2931
- response = {
2932
- ...(await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context)),
2933
- name: errorCode,
2934
- $metadata: deserializeMetadata(output),
2935
- };
2936
- break;
2005
+ throw await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context);
2937
2006
  case "LoadBalancerNotFoundException":
2938
2007
  case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
2939
- response = {
2940
- ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
2941
- name: errorCode,
2942
- $metadata: deserializeMetadata(output),
2943
- };
2944
- break;
2008
+ throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
2945
2009
  case "SubnetNotFoundException":
2946
2010
  case "com.amazonaws.elasticloadbalancingv2#SubnetNotFoundException":
2947
- response = {
2948
- ...(await deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context)),
2949
- name: errorCode,
2950
- $metadata: deserializeMetadata(output),
2951
- };
2952
- break;
2011
+ throw await deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context);
2953
2012
  default:
2954
2013
  const parsedBody = parsedOutput.body;
2955
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2956
- response = {
2957
- ...parsedBody.Error,
2958
- name: `${errorCode}`,
2959
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
2014
+ response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
2015
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2960
2016
  $fault: "client",
2961
2017
  $metadata: deserializeMetadata(output),
2962
- };
2018
+ });
2019
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2963
2020
  }
2964
- const message = response.message || response.Message || errorCode;
2965
- response.message = message;
2966
- delete response.Message;
2967
- return Promise.reject(Object.assign(new Error(message), response));
2968
2021
  };
2969
2022
  const deserializeAws_queryAllocationIdNotFoundExceptionResponse = async (parsedOutput, context) => {
2970
2023
  const body = parsedOutput.body;
2971
2024
  const deserialized = deserializeAws_queryAllocationIdNotFoundException(body.Error, context);
2972
- const contents = {
2973
- name: "AllocationIdNotFoundException",
2974
- $fault: "client",
2025
+ const exception = new models_0_1.AllocationIdNotFoundException({
2975
2026
  $metadata: deserializeMetadata(parsedOutput),
2976
2027
  ...deserialized,
2977
- };
2978
- return contents;
2028
+ });
2029
+ return smithy_client_1.decorateServiceException(exception, body);
2979
2030
  };
2980
2031
  const deserializeAws_queryALPNPolicyNotSupportedExceptionResponse = async (parsedOutput, context) => {
2981
2032
  const body = parsedOutput.body;
2982
2033
  const deserialized = deserializeAws_queryALPNPolicyNotSupportedException(body.Error, context);
2983
- const contents = {
2984
- name: "ALPNPolicyNotSupportedException",
2985
- $fault: "client",
2034
+ const exception = new models_0_1.ALPNPolicyNotSupportedException({
2986
2035
  $metadata: deserializeMetadata(parsedOutput),
2987
2036
  ...deserialized,
2988
- };
2989
- return contents;
2037
+ });
2038
+ return smithy_client_1.decorateServiceException(exception, body);
2990
2039
  };
2991
2040
  const deserializeAws_queryAvailabilityZoneNotSupportedExceptionResponse = async (parsedOutput, context) => {
2992
2041
  const body = parsedOutput.body;
2993
2042
  const deserialized = deserializeAws_queryAvailabilityZoneNotSupportedException(body.Error, context);
2994
- const contents = {
2995
- name: "AvailabilityZoneNotSupportedException",
2996
- $fault: "client",
2043
+ const exception = new models_0_1.AvailabilityZoneNotSupportedException({
2997
2044
  $metadata: deserializeMetadata(parsedOutput),
2998
2045
  ...deserialized,
2999
- };
3000
- return contents;
2046
+ });
2047
+ return smithy_client_1.decorateServiceException(exception, body);
3001
2048
  };
3002
2049
  const deserializeAws_queryCertificateNotFoundExceptionResponse = async (parsedOutput, context) => {
3003
2050
  const body = parsedOutput.body;
3004
2051
  const deserialized = deserializeAws_queryCertificateNotFoundException(body.Error, context);
3005
- const contents = {
3006
- name: "CertificateNotFoundException",
3007
- $fault: "client",
2052
+ const exception = new models_0_1.CertificateNotFoundException({
3008
2053
  $metadata: deserializeMetadata(parsedOutput),
3009
2054
  ...deserialized,
3010
- };
3011
- return contents;
2055
+ });
2056
+ return smithy_client_1.decorateServiceException(exception, body);
3012
2057
  };
3013
2058
  const deserializeAws_queryDuplicateListenerExceptionResponse = async (parsedOutput, context) => {
3014
2059
  const body = parsedOutput.body;
3015
2060
  const deserialized = deserializeAws_queryDuplicateListenerException(body.Error, context);
3016
- const contents = {
3017
- name: "DuplicateListenerException",
3018
- $fault: "client",
2061
+ const exception = new models_0_1.DuplicateListenerException({
3019
2062
  $metadata: deserializeMetadata(parsedOutput),
3020
2063
  ...deserialized,
3021
- };
3022
- return contents;
2064
+ });
2065
+ return smithy_client_1.decorateServiceException(exception, body);
3023
2066
  };
3024
2067
  const deserializeAws_queryDuplicateLoadBalancerNameExceptionResponse = async (parsedOutput, context) => {
3025
2068
  const body = parsedOutput.body;
3026
2069
  const deserialized = deserializeAws_queryDuplicateLoadBalancerNameException(body.Error, context);
3027
- const contents = {
3028
- name: "DuplicateLoadBalancerNameException",
3029
- $fault: "client",
2070
+ const exception = new models_0_1.DuplicateLoadBalancerNameException({
3030
2071
  $metadata: deserializeMetadata(parsedOutput),
3031
2072
  ...deserialized,
3032
- };
3033
- return contents;
2073
+ });
2074
+ return smithy_client_1.decorateServiceException(exception, body);
3034
2075
  };
3035
2076
  const deserializeAws_queryDuplicateTagKeysExceptionResponse = async (parsedOutput, context) => {
3036
2077
  const body = parsedOutput.body;
3037
2078
  const deserialized = deserializeAws_queryDuplicateTagKeysException(body.Error, context);
3038
- const contents = {
3039
- name: "DuplicateTagKeysException",
3040
- $fault: "client",
2079
+ const exception = new models_0_1.DuplicateTagKeysException({
3041
2080
  $metadata: deserializeMetadata(parsedOutput),
3042
2081
  ...deserialized,
3043
- };
3044
- return contents;
2082
+ });
2083
+ return smithy_client_1.decorateServiceException(exception, body);
3045
2084
  };
3046
2085
  const deserializeAws_queryDuplicateTargetGroupNameExceptionResponse = async (parsedOutput, context) => {
3047
2086
  const body = parsedOutput.body;
3048
2087
  const deserialized = deserializeAws_queryDuplicateTargetGroupNameException(body.Error, context);
3049
- const contents = {
3050
- name: "DuplicateTargetGroupNameException",
3051
- $fault: "client",
2088
+ const exception = new models_0_1.DuplicateTargetGroupNameException({
3052
2089
  $metadata: deserializeMetadata(parsedOutput),
3053
2090
  ...deserialized,
3054
- };
3055
- return contents;
2091
+ });
2092
+ return smithy_client_1.decorateServiceException(exception, body);
3056
2093
  };
3057
2094
  const deserializeAws_queryHealthUnavailableExceptionResponse = async (parsedOutput, context) => {
3058
2095
  const body = parsedOutput.body;
3059
2096
  const deserialized = deserializeAws_queryHealthUnavailableException(body.Error, context);
3060
- const contents = {
3061
- name: "HealthUnavailableException",
3062
- $fault: "server",
2097
+ const exception = new models_0_1.HealthUnavailableException({
3063
2098
  $metadata: deserializeMetadata(parsedOutput),
3064
2099
  ...deserialized,
3065
- };
3066
- return contents;
2100
+ });
2101
+ return smithy_client_1.decorateServiceException(exception, body);
3067
2102
  };
3068
2103
  const deserializeAws_queryIncompatibleProtocolsExceptionResponse = async (parsedOutput, context) => {
3069
2104
  const body = parsedOutput.body;
3070
2105
  const deserialized = deserializeAws_queryIncompatibleProtocolsException(body.Error, context);
3071
- const contents = {
3072
- name: "IncompatibleProtocolsException",
3073
- $fault: "client",
2106
+ const exception = new models_0_1.IncompatibleProtocolsException({
3074
2107
  $metadata: deserializeMetadata(parsedOutput),
3075
2108
  ...deserialized,
3076
- };
3077
- return contents;
2109
+ });
2110
+ return smithy_client_1.decorateServiceException(exception, body);
3078
2111
  };
3079
2112
  const deserializeAws_queryInvalidConfigurationRequestExceptionResponse = async (parsedOutput, context) => {
3080
2113
  const body = parsedOutput.body;
3081
2114
  const deserialized = deserializeAws_queryInvalidConfigurationRequestException(body.Error, context);
3082
- const contents = {
3083
- name: "InvalidConfigurationRequestException",
3084
- $fault: "client",
2115
+ const exception = new models_0_1.InvalidConfigurationRequestException({
3085
2116
  $metadata: deserializeMetadata(parsedOutput),
3086
2117
  ...deserialized,
3087
- };
3088
- return contents;
2118
+ });
2119
+ return smithy_client_1.decorateServiceException(exception, body);
3089
2120
  };
3090
2121
  const deserializeAws_queryInvalidLoadBalancerActionExceptionResponse = async (parsedOutput, context) => {
3091
2122
  const body = parsedOutput.body;
3092
2123
  const deserialized = deserializeAws_queryInvalidLoadBalancerActionException(body.Error, context);
3093
- const contents = {
3094
- name: "InvalidLoadBalancerActionException",
3095
- $fault: "client",
2124
+ const exception = new models_0_1.InvalidLoadBalancerActionException({
3096
2125
  $metadata: deserializeMetadata(parsedOutput),
3097
2126
  ...deserialized,
3098
- };
3099
- return contents;
2127
+ });
2128
+ return smithy_client_1.decorateServiceException(exception, body);
3100
2129
  };
3101
2130
  const deserializeAws_queryInvalidSchemeExceptionResponse = async (parsedOutput, context) => {
3102
2131
  const body = parsedOutput.body;
3103
2132
  const deserialized = deserializeAws_queryInvalidSchemeException(body.Error, context);
3104
- const contents = {
3105
- name: "InvalidSchemeException",
3106
- $fault: "client",
2133
+ const exception = new models_0_1.InvalidSchemeException({
3107
2134
  $metadata: deserializeMetadata(parsedOutput),
3108
2135
  ...deserialized,
3109
- };
3110
- return contents;
2136
+ });
2137
+ return smithy_client_1.decorateServiceException(exception, body);
3111
2138
  };
3112
2139
  const deserializeAws_queryInvalidSecurityGroupExceptionResponse = async (parsedOutput, context) => {
3113
2140
  const body = parsedOutput.body;
3114
2141
  const deserialized = deserializeAws_queryInvalidSecurityGroupException(body.Error, context);
3115
- const contents = {
3116
- name: "InvalidSecurityGroupException",
3117
- $fault: "client",
2142
+ const exception = new models_0_1.InvalidSecurityGroupException({
3118
2143
  $metadata: deserializeMetadata(parsedOutput),
3119
2144
  ...deserialized,
3120
- };
3121
- return contents;
2145
+ });
2146
+ return smithy_client_1.decorateServiceException(exception, body);
3122
2147
  };
3123
2148
  const deserializeAws_queryInvalidSubnetExceptionResponse = async (parsedOutput, context) => {
3124
2149
  const body = parsedOutput.body;
3125
2150
  const deserialized = deserializeAws_queryInvalidSubnetException(body.Error, context);
3126
- const contents = {
3127
- name: "InvalidSubnetException",
3128
- $fault: "client",
2151
+ const exception = new models_0_1.InvalidSubnetException({
3129
2152
  $metadata: deserializeMetadata(parsedOutput),
3130
2153
  ...deserialized,
3131
- };
3132
- return contents;
2154
+ });
2155
+ return smithy_client_1.decorateServiceException(exception, body);
3133
2156
  };
3134
2157
  const deserializeAws_queryInvalidTargetExceptionResponse = async (parsedOutput, context) => {
3135
2158
  const body = parsedOutput.body;
3136
2159
  const deserialized = deserializeAws_queryInvalidTargetException(body.Error, context);
3137
- const contents = {
3138
- name: "InvalidTargetException",
3139
- $fault: "client",
2160
+ const exception = new models_0_1.InvalidTargetException({
3140
2161
  $metadata: deserializeMetadata(parsedOutput),
3141
2162
  ...deserialized,
3142
- };
3143
- return contents;
2163
+ });
2164
+ return smithy_client_1.decorateServiceException(exception, body);
3144
2165
  };
3145
2166
  const deserializeAws_queryListenerNotFoundExceptionResponse = async (parsedOutput, context) => {
3146
2167
  const body = parsedOutput.body;
3147
2168
  const deserialized = deserializeAws_queryListenerNotFoundException(body.Error, context);
3148
- const contents = {
3149
- name: "ListenerNotFoundException",
3150
- $fault: "client",
2169
+ const exception = new models_0_1.ListenerNotFoundException({
3151
2170
  $metadata: deserializeMetadata(parsedOutput),
3152
2171
  ...deserialized,
3153
- };
3154
- return contents;
2172
+ });
2173
+ return smithy_client_1.decorateServiceException(exception, body);
3155
2174
  };
3156
2175
  const deserializeAws_queryLoadBalancerNotFoundExceptionResponse = async (parsedOutput, context) => {
3157
2176
  const body = parsedOutput.body;
3158
2177
  const deserialized = deserializeAws_queryLoadBalancerNotFoundException(body.Error, context);
3159
- const contents = {
3160
- name: "LoadBalancerNotFoundException",
3161
- $fault: "client",
2178
+ const exception = new models_0_1.LoadBalancerNotFoundException({
3162
2179
  $metadata: deserializeMetadata(parsedOutput),
3163
2180
  ...deserialized,
3164
- };
3165
- return contents;
2181
+ });
2182
+ return smithy_client_1.decorateServiceException(exception, body);
3166
2183
  };
3167
2184
  const deserializeAws_queryOperationNotPermittedExceptionResponse = async (parsedOutput, context) => {
3168
2185
  const body = parsedOutput.body;
3169
2186
  const deserialized = deserializeAws_queryOperationNotPermittedException(body.Error, context);
3170
- const contents = {
3171
- name: "OperationNotPermittedException",
3172
- $fault: "client",
2187
+ const exception = new models_0_1.OperationNotPermittedException({
3173
2188
  $metadata: deserializeMetadata(parsedOutput),
3174
2189
  ...deserialized,
3175
- };
3176
- return contents;
2190
+ });
2191
+ return smithy_client_1.decorateServiceException(exception, body);
3177
2192
  };
3178
2193
  const deserializeAws_queryPriorityInUseExceptionResponse = async (parsedOutput, context) => {
3179
2194
  const body = parsedOutput.body;
3180
2195
  const deserialized = deserializeAws_queryPriorityInUseException(body.Error, context);
3181
- const contents = {
3182
- name: "PriorityInUseException",
3183
- $fault: "client",
2196
+ const exception = new models_0_1.PriorityInUseException({
3184
2197
  $metadata: deserializeMetadata(parsedOutput),
3185
2198
  ...deserialized,
3186
- };
3187
- return contents;
2199
+ });
2200
+ return smithy_client_1.decorateServiceException(exception, body);
3188
2201
  };
3189
2202
  const deserializeAws_queryResourceInUseExceptionResponse = async (parsedOutput, context) => {
3190
2203
  const body = parsedOutput.body;
3191
2204
  const deserialized = deserializeAws_queryResourceInUseException(body.Error, context);
3192
- const contents = {
3193
- name: "ResourceInUseException",
3194
- $fault: "client",
2205
+ const exception = new models_0_1.ResourceInUseException({
3195
2206
  $metadata: deserializeMetadata(parsedOutput),
3196
2207
  ...deserialized,
3197
- };
3198
- return contents;
2208
+ });
2209
+ return smithy_client_1.decorateServiceException(exception, body);
3199
2210
  };
3200
2211
  const deserializeAws_queryRuleNotFoundExceptionResponse = async (parsedOutput, context) => {
3201
2212
  const body = parsedOutput.body;
3202
2213
  const deserialized = deserializeAws_queryRuleNotFoundException(body.Error, context);
3203
- const contents = {
3204
- name: "RuleNotFoundException",
3205
- $fault: "client",
2214
+ const exception = new models_0_1.RuleNotFoundException({
3206
2215
  $metadata: deserializeMetadata(parsedOutput),
3207
2216
  ...deserialized,
3208
- };
3209
- return contents;
2217
+ });
2218
+ return smithy_client_1.decorateServiceException(exception, body);
3210
2219
  };
3211
2220
  const deserializeAws_querySSLPolicyNotFoundExceptionResponse = async (parsedOutput, context) => {
3212
2221
  const body = parsedOutput.body;
3213
2222
  const deserialized = deserializeAws_querySSLPolicyNotFoundException(body.Error, context);
3214
- const contents = {
3215
- name: "SSLPolicyNotFoundException",
3216
- $fault: "client",
2223
+ const exception = new models_0_1.SSLPolicyNotFoundException({
3217
2224
  $metadata: deserializeMetadata(parsedOutput),
3218
2225
  ...deserialized,
3219
- };
3220
- return contents;
2226
+ });
2227
+ return smithy_client_1.decorateServiceException(exception, body);
3221
2228
  };
3222
2229
  const deserializeAws_querySubnetNotFoundExceptionResponse = async (parsedOutput, context) => {
3223
2230
  const body = parsedOutput.body;
3224
2231
  const deserialized = deserializeAws_querySubnetNotFoundException(body.Error, context);
3225
- const contents = {
3226
- name: "SubnetNotFoundException",
3227
- $fault: "client",
2232
+ const exception = new models_0_1.SubnetNotFoundException({
3228
2233
  $metadata: deserializeMetadata(parsedOutput),
3229
2234
  ...deserialized,
3230
- };
3231
- return contents;
2235
+ });
2236
+ return smithy_client_1.decorateServiceException(exception, body);
3232
2237
  };
3233
2238
  const deserializeAws_queryTargetGroupAssociationLimitExceptionResponse = async (parsedOutput, context) => {
3234
2239
  const body = parsedOutput.body;
3235
2240
  const deserialized = deserializeAws_queryTargetGroupAssociationLimitException(body.Error, context);
3236
- const contents = {
3237
- name: "TargetGroupAssociationLimitException",
3238
- $fault: "client",
2241
+ const exception = new models_0_1.TargetGroupAssociationLimitException({
3239
2242
  $metadata: deserializeMetadata(parsedOutput),
3240
2243
  ...deserialized,
3241
- };
3242
- return contents;
2244
+ });
2245
+ return smithy_client_1.decorateServiceException(exception, body);
3243
2246
  };
3244
2247
  const deserializeAws_queryTargetGroupNotFoundExceptionResponse = async (parsedOutput, context) => {
3245
2248
  const body = parsedOutput.body;
3246
2249
  const deserialized = deserializeAws_queryTargetGroupNotFoundException(body.Error, context);
3247
- const contents = {
3248
- name: "TargetGroupNotFoundException",
3249
- $fault: "client",
2250
+ const exception = new models_0_1.TargetGroupNotFoundException({
3250
2251
  $metadata: deserializeMetadata(parsedOutput),
3251
2252
  ...deserialized,
3252
- };
3253
- return contents;
2253
+ });
2254
+ return smithy_client_1.decorateServiceException(exception, body);
3254
2255
  };
3255
2256
  const deserializeAws_queryTooManyActionsExceptionResponse = async (parsedOutput, context) => {
3256
2257
  const body = parsedOutput.body;
3257
2258
  const deserialized = deserializeAws_queryTooManyActionsException(body.Error, context);
3258
- const contents = {
3259
- name: "TooManyActionsException",
3260
- $fault: "client",
2259
+ const exception = new models_0_1.TooManyActionsException({
3261
2260
  $metadata: deserializeMetadata(parsedOutput),
3262
2261
  ...deserialized,
3263
- };
3264
- return contents;
2262
+ });
2263
+ return smithy_client_1.decorateServiceException(exception, body);
3265
2264
  };
3266
2265
  const deserializeAws_queryTooManyCertificatesExceptionResponse = async (parsedOutput, context) => {
3267
2266
  const body = parsedOutput.body;
3268
2267
  const deserialized = deserializeAws_queryTooManyCertificatesException(body.Error, context);
3269
- const contents = {
3270
- name: "TooManyCertificatesException",
3271
- $fault: "client",
2268
+ const exception = new models_0_1.TooManyCertificatesException({
3272
2269
  $metadata: deserializeMetadata(parsedOutput),
3273
2270
  ...deserialized,
3274
- };
3275
- return contents;
2271
+ });
2272
+ return smithy_client_1.decorateServiceException(exception, body);
3276
2273
  };
3277
2274
  const deserializeAws_queryTooManyListenersExceptionResponse = async (parsedOutput, context) => {
3278
2275
  const body = parsedOutput.body;
3279
2276
  const deserialized = deserializeAws_queryTooManyListenersException(body.Error, context);
3280
- const contents = {
3281
- name: "TooManyListenersException",
3282
- $fault: "client",
2277
+ const exception = new models_0_1.TooManyListenersException({
3283
2278
  $metadata: deserializeMetadata(parsedOutput),
3284
2279
  ...deserialized,
3285
- };
3286
- return contents;
2280
+ });
2281
+ return smithy_client_1.decorateServiceException(exception, body);
3287
2282
  };
3288
2283
  const deserializeAws_queryTooManyLoadBalancersExceptionResponse = async (parsedOutput, context) => {
3289
2284
  const body = parsedOutput.body;
3290
2285
  const deserialized = deserializeAws_queryTooManyLoadBalancersException(body.Error, context);
3291
- const contents = {
3292
- name: "TooManyLoadBalancersException",
3293
- $fault: "client",
2286
+ const exception = new models_0_1.TooManyLoadBalancersException({
3294
2287
  $metadata: deserializeMetadata(parsedOutput),
3295
2288
  ...deserialized,
3296
- };
3297
- return contents;
2289
+ });
2290
+ return smithy_client_1.decorateServiceException(exception, body);
3298
2291
  };
3299
2292
  const deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse = async (parsedOutput, context) => {
3300
2293
  const body = parsedOutput.body;
3301
2294
  const deserialized = deserializeAws_queryTooManyRegistrationsForTargetIdException(body.Error, context);
3302
- const contents = {
3303
- name: "TooManyRegistrationsForTargetIdException",
3304
- $fault: "client",
2295
+ const exception = new models_0_1.TooManyRegistrationsForTargetIdException({
3305
2296
  $metadata: deserializeMetadata(parsedOutput),
3306
2297
  ...deserialized,
3307
- };
3308
- return contents;
2298
+ });
2299
+ return smithy_client_1.decorateServiceException(exception, body);
3309
2300
  };
3310
2301
  const deserializeAws_queryTooManyRulesExceptionResponse = async (parsedOutput, context) => {
3311
2302
  const body = parsedOutput.body;
3312
2303
  const deserialized = deserializeAws_queryTooManyRulesException(body.Error, context);
3313
- const contents = {
3314
- name: "TooManyRulesException",
3315
- $fault: "client",
2304
+ const exception = new models_0_1.TooManyRulesException({
3316
2305
  $metadata: deserializeMetadata(parsedOutput),
3317
2306
  ...deserialized,
3318
- };
3319
- return contents;
2307
+ });
2308
+ return smithy_client_1.decorateServiceException(exception, body);
3320
2309
  };
3321
2310
  const deserializeAws_queryTooManyTagsExceptionResponse = async (parsedOutput, context) => {
3322
2311
  const body = parsedOutput.body;
3323
2312
  const deserialized = deserializeAws_queryTooManyTagsException(body.Error, context);
3324
- const contents = {
3325
- name: "TooManyTagsException",
3326
- $fault: "client",
2313
+ const exception = new models_0_1.TooManyTagsException({
3327
2314
  $metadata: deserializeMetadata(parsedOutput),
3328
2315
  ...deserialized,
3329
- };
3330
- return contents;
2316
+ });
2317
+ return smithy_client_1.decorateServiceException(exception, body);
3331
2318
  };
3332
2319
  const deserializeAws_queryTooManyTargetGroupsExceptionResponse = async (parsedOutput, context) => {
3333
2320
  const body = parsedOutput.body;
3334
2321
  const deserialized = deserializeAws_queryTooManyTargetGroupsException(body.Error, context);
3335
- const contents = {
3336
- name: "TooManyTargetGroupsException",
3337
- $fault: "client",
2322
+ const exception = new models_0_1.TooManyTargetGroupsException({
3338
2323
  $metadata: deserializeMetadata(parsedOutput),
3339
2324
  ...deserialized,
3340
- };
3341
- return contents;
2325
+ });
2326
+ return smithy_client_1.decorateServiceException(exception, body);
3342
2327
  };
3343
2328
  const deserializeAws_queryTooManyTargetsExceptionResponse = async (parsedOutput, context) => {
3344
2329
  const body = parsedOutput.body;
3345
2330
  const deserialized = deserializeAws_queryTooManyTargetsException(body.Error, context);
3346
- const contents = {
3347
- name: "TooManyTargetsException",
3348
- $fault: "client",
2331
+ const exception = new models_0_1.TooManyTargetsException({
3349
2332
  $metadata: deserializeMetadata(parsedOutput),
3350
2333
  ...deserialized,
3351
- };
3352
- return contents;
2334
+ });
2335
+ return smithy_client_1.decorateServiceException(exception, body);
3353
2336
  };
3354
2337
  const deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse = async (parsedOutput, context) => {
3355
2338
  const body = parsedOutput.body;
3356
2339
  const deserialized = deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerException(body.Error, context);
3357
- const contents = {
3358
- name: "TooManyUniqueTargetGroupsPerLoadBalancerException",
3359
- $fault: "client",
2340
+ const exception = new models_0_1.TooManyUniqueTargetGroupsPerLoadBalancerException({
3360
2341
  $metadata: deserializeMetadata(parsedOutput),
3361
2342
  ...deserialized,
3362
- };
3363
- return contents;
2343
+ });
2344
+ return smithy_client_1.decorateServiceException(exception, body);
3364
2345
  };
3365
2346
  const deserializeAws_queryUnsupportedProtocolExceptionResponse = async (parsedOutput, context) => {
3366
2347
  const body = parsedOutput.body;
3367
2348
  const deserialized = deserializeAws_queryUnsupportedProtocolException(body.Error, context);
3368
- const contents = {
3369
- name: "UnsupportedProtocolException",
3370
- $fault: "client",
2349
+ const exception = new models_0_1.UnsupportedProtocolException({
3371
2350
  $metadata: deserializeMetadata(parsedOutput),
3372
2351
  ...deserialized,
3373
- };
3374
- return contents;
2352
+ });
2353
+ return smithy_client_1.decorateServiceException(exception, body);
3375
2354
  };
3376
2355
  const serializeAws_queryAction = (input, context) => {
3377
2356
  const entries = {};