@aws-sdk/client-elastic-load-balancing-v2 3.179.0 → 3.181.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +26 -0
- package/dist-cjs/protocols/Aws_query.js +191 -183
- package/dist-es/protocols/Aws_query.js +198 -183
- package/package.json +7 -7
|
@@ -467,17 +467,17 @@ exports.deserializeAws_queryAddListenerCertificatesCommand = deserializeAws_quer
|
|
|
467
467
|
const deserializeAws_queryAddListenerCertificatesCommandError = async (output, context) => {
|
|
468
468
|
const parsedOutput = {
|
|
469
469
|
...output,
|
|
470
|
-
body: await
|
|
470
|
+
body: await parseErrorBody(output.body, context),
|
|
471
471
|
};
|
|
472
472
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
473
473
|
switch (errorCode) {
|
|
474
|
-
case "
|
|
474
|
+
case "CertificateNotFound":
|
|
475
475
|
case "com.amazonaws.elasticloadbalancingv2#CertificateNotFoundException":
|
|
476
476
|
throw await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context);
|
|
477
|
-
case "
|
|
477
|
+
case "ListenerNotFound":
|
|
478
478
|
case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
|
|
479
479
|
throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
|
|
480
|
-
case "
|
|
480
|
+
case "TooManyCertificates":
|
|
481
481
|
case "com.amazonaws.elasticloadbalancingv2#TooManyCertificatesException":
|
|
482
482
|
throw await deserializeAws_queryTooManyCertificatesExceptionResponse(parsedOutput, context);
|
|
483
483
|
default:
|
|
@@ -507,26 +507,26 @@ exports.deserializeAws_queryAddTagsCommand = deserializeAws_queryAddTagsCommand;
|
|
|
507
507
|
const deserializeAws_queryAddTagsCommandError = async (output, context) => {
|
|
508
508
|
const parsedOutput = {
|
|
509
509
|
...output,
|
|
510
|
-
body: await
|
|
510
|
+
body: await parseErrorBody(output.body, context),
|
|
511
511
|
};
|
|
512
512
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
513
513
|
switch (errorCode) {
|
|
514
|
-
case "
|
|
514
|
+
case "DuplicateTagKeys":
|
|
515
515
|
case "com.amazonaws.elasticloadbalancingv2#DuplicateTagKeysException":
|
|
516
516
|
throw await deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context);
|
|
517
|
-
case "
|
|
517
|
+
case "ListenerNotFound":
|
|
518
518
|
case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
|
|
519
519
|
throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
|
|
520
|
-
case "
|
|
520
|
+
case "LoadBalancerNotFound":
|
|
521
521
|
case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
|
|
522
522
|
throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
|
|
523
|
-
case "
|
|
523
|
+
case "RuleNotFound":
|
|
524
524
|
case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
|
|
525
525
|
throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
|
|
526
|
-
case "
|
|
526
|
+
case "TargetGroupNotFound":
|
|
527
527
|
case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
|
|
528
528
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
529
|
-
case "
|
|
529
|
+
case "TooManyTags":
|
|
530
530
|
case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
|
|
531
531
|
throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
|
|
532
532
|
default:
|
|
@@ -556,62 +556,62 @@ exports.deserializeAws_queryCreateListenerCommand = deserializeAws_queryCreateLi
|
|
|
556
556
|
const deserializeAws_queryCreateListenerCommandError = async (output, context) => {
|
|
557
557
|
const parsedOutput = {
|
|
558
558
|
...output,
|
|
559
|
-
body: await
|
|
559
|
+
body: await parseErrorBody(output.body, context),
|
|
560
560
|
};
|
|
561
561
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
562
562
|
switch (errorCode) {
|
|
563
|
-
case "
|
|
563
|
+
case "ALPNPolicyNotFound":
|
|
564
564
|
case "com.amazonaws.elasticloadbalancingv2#ALPNPolicyNotSupportedException":
|
|
565
565
|
throw await deserializeAws_queryALPNPolicyNotSupportedExceptionResponse(parsedOutput, context);
|
|
566
|
-
case "
|
|
566
|
+
case "CertificateNotFound":
|
|
567
567
|
case "com.amazonaws.elasticloadbalancingv2#CertificateNotFoundException":
|
|
568
568
|
throw await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context);
|
|
569
|
-
case "
|
|
569
|
+
case "DuplicateListener":
|
|
570
570
|
case "com.amazonaws.elasticloadbalancingv2#DuplicateListenerException":
|
|
571
571
|
throw await deserializeAws_queryDuplicateListenerExceptionResponse(parsedOutput, context);
|
|
572
|
-
case "
|
|
572
|
+
case "IncompatibleProtocols":
|
|
573
573
|
case "com.amazonaws.elasticloadbalancingv2#IncompatibleProtocolsException":
|
|
574
574
|
throw await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context);
|
|
575
|
-
case "
|
|
575
|
+
case "InvalidConfigurationRequest":
|
|
576
576
|
case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
|
|
577
577
|
throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
|
|
578
|
-
case "
|
|
578
|
+
case "InvalidLoadBalancerAction":
|
|
579
579
|
case "com.amazonaws.elasticloadbalancingv2#InvalidLoadBalancerActionException":
|
|
580
580
|
throw await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context);
|
|
581
|
-
case "
|
|
581
|
+
case "LoadBalancerNotFound":
|
|
582
582
|
case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
|
|
583
583
|
throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
|
|
584
|
-
case "
|
|
584
|
+
case "SSLPolicyNotFound":
|
|
585
585
|
case "com.amazonaws.elasticloadbalancingv2#SSLPolicyNotFoundException":
|
|
586
586
|
throw await deserializeAws_querySSLPolicyNotFoundExceptionResponse(parsedOutput, context);
|
|
587
|
-
case "
|
|
587
|
+
case "TargetGroupAssociationLimit":
|
|
588
588
|
case "com.amazonaws.elasticloadbalancingv2#TargetGroupAssociationLimitException":
|
|
589
589
|
throw await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context);
|
|
590
|
-
case "
|
|
590
|
+
case "TargetGroupNotFound":
|
|
591
591
|
case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
|
|
592
592
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
593
|
-
case "
|
|
593
|
+
case "TooManyActions":
|
|
594
594
|
case "com.amazonaws.elasticloadbalancingv2#TooManyActionsException":
|
|
595
595
|
throw await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context);
|
|
596
|
-
case "
|
|
596
|
+
case "TooManyCertificates":
|
|
597
597
|
case "com.amazonaws.elasticloadbalancingv2#TooManyCertificatesException":
|
|
598
598
|
throw await deserializeAws_queryTooManyCertificatesExceptionResponse(parsedOutput, context);
|
|
599
|
-
case "
|
|
599
|
+
case "TooManyListeners":
|
|
600
600
|
case "com.amazonaws.elasticloadbalancingv2#TooManyListenersException":
|
|
601
601
|
throw await deserializeAws_queryTooManyListenersExceptionResponse(parsedOutput, context);
|
|
602
|
-
case "
|
|
602
|
+
case "TooManyRegistrationsForTargetId":
|
|
603
603
|
case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
|
|
604
604
|
throw await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context);
|
|
605
|
-
case "
|
|
605
|
+
case "TooManyTags":
|
|
606
606
|
case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
|
|
607
607
|
throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
|
|
608
|
-
case "
|
|
608
|
+
case "TooManyTargets":
|
|
609
609
|
case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
|
|
610
610
|
throw await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context);
|
|
611
|
-
case "
|
|
611
|
+
case "TooManyUniqueTargetGroupsPerLoadBalancer":
|
|
612
612
|
case "com.amazonaws.elasticloadbalancingv2#TooManyUniqueTargetGroupsPerLoadBalancerException":
|
|
613
613
|
throw await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context);
|
|
614
|
-
case "
|
|
614
|
+
case "UnsupportedProtocol":
|
|
615
615
|
case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
|
|
616
616
|
throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
|
|
617
617
|
default:
|
|
@@ -641,47 +641,47 @@ exports.deserializeAws_queryCreateLoadBalancerCommand = deserializeAws_queryCrea
|
|
|
641
641
|
const deserializeAws_queryCreateLoadBalancerCommandError = async (output, context) => {
|
|
642
642
|
const parsedOutput = {
|
|
643
643
|
...output,
|
|
644
|
-
body: await
|
|
644
|
+
body: await parseErrorBody(output.body, context),
|
|
645
645
|
};
|
|
646
646
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
647
647
|
switch (errorCode) {
|
|
648
|
-
case "
|
|
648
|
+
case "AllocationIdNotFound":
|
|
649
649
|
case "com.amazonaws.elasticloadbalancingv2#AllocationIdNotFoundException":
|
|
650
650
|
throw await deserializeAws_queryAllocationIdNotFoundExceptionResponse(parsedOutput, context);
|
|
651
|
-
case "
|
|
651
|
+
case "AvailabilityZoneNotSupported":
|
|
652
652
|
case "com.amazonaws.elasticloadbalancingv2#AvailabilityZoneNotSupportedException":
|
|
653
653
|
throw await deserializeAws_queryAvailabilityZoneNotSupportedExceptionResponse(parsedOutput, context);
|
|
654
|
-
case "
|
|
654
|
+
case "DuplicateLoadBalancerName":
|
|
655
655
|
case "com.amazonaws.elasticloadbalancingv2#DuplicateLoadBalancerNameException":
|
|
656
656
|
throw await deserializeAws_queryDuplicateLoadBalancerNameExceptionResponse(parsedOutput, context);
|
|
657
|
-
case "
|
|
657
|
+
case "DuplicateTagKeys":
|
|
658
658
|
case "com.amazonaws.elasticloadbalancingv2#DuplicateTagKeysException":
|
|
659
659
|
throw await deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context);
|
|
660
|
-
case "
|
|
660
|
+
case "InvalidConfigurationRequest":
|
|
661
661
|
case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
|
|
662
662
|
throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
|
|
663
|
-
case "
|
|
663
|
+
case "InvalidScheme":
|
|
664
664
|
case "com.amazonaws.elasticloadbalancingv2#InvalidSchemeException":
|
|
665
665
|
throw await deserializeAws_queryInvalidSchemeExceptionResponse(parsedOutput, context);
|
|
666
|
-
case "
|
|
666
|
+
case "InvalidSecurityGroup":
|
|
667
667
|
case "com.amazonaws.elasticloadbalancingv2#InvalidSecurityGroupException":
|
|
668
668
|
throw await deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context);
|
|
669
|
-
case "
|
|
669
|
+
case "InvalidSubnet":
|
|
670
670
|
case "com.amazonaws.elasticloadbalancingv2#InvalidSubnetException":
|
|
671
671
|
throw await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context);
|
|
672
|
-
case "
|
|
672
|
+
case "OperationNotPermitted":
|
|
673
673
|
case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
|
|
674
674
|
throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
|
|
675
|
-
case "
|
|
675
|
+
case "ResourceInUse":
|
|
676
676
|
case "com.amazonaws.elasticloadbalancingv2#ResourceInUseException":
|
|
677
677
|
throw await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context);
|
|
678
|
-
case "
|
|
678
|
+
case "SubnetNotFound":
|
|
679
679
|
case "com.amazonaws.elasticloadbalancingv2#SubnetNotFoundException":
|
|
680
680
|
throw await deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context);
|
|
681
|
-
case "
|
|
681
|
+
case "TooManyLoadBalancers":
|
|
682
682
|
case "com.amazonaws.elasticloadbalancingv2#TooManyLoadBalancersException":
|
|
683
683
|
throw await deserializeAws_queryTooManyLoadBalancersExceptionResponse(parsedOutput, context);
|
|
684
|
-
case "
|
|
684
|
+
case "TooManyTags":
|
|
685
685
|
case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
|
|
686
686
|
throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
|
|
687
687
|
default:
|
|
@@ -711,53 +711,53 @@ exports.deserializeAws_queryCreateRuleCommand = deserializeAws_queryCreateRuleCo
|
|
|
711
711
|
const deserializeAws_queryCreateRuleCommandError = async (output, context) => {
|
|
712
712
|
const parsedOutput = {
|
|
713
713
|
...output,
|
|
714
|
-
body: await
|
|
714
|
+
body: await parseErrorBody(output.body, context),
|
|
715
715
|
};
|
|
716
716
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
717
717
|
switch (errorCode) {
|
|
718
|
-
case "
|
|
718
|
+
case "IncompatibleProtocols":
|
|
719
719
|
case "com.amazonaws.elasticloadbalancingv2#IncompatibleProtocolsException":
|
|
720
720
|
throw await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context);
|
|
721
|
-
case "
|
|
721
|
+
case "InvalidConfigurationRequest":
|
|
722
722
|
case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
|
|
723
723
|
throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
|
|
724
|
-
case "
|
|
724
|
+
case "InvalidLoadBalancerAction":
|
|
725
725
|
case "com.amazonaws.elasticloadbalancingv2#InvalidLoadBalancerActionException":
|
|
726
726
|
throw await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context);
|
|
727
|
-
case "
|
|
727
|
+
case "ListenerNotFound":
|
|
728
728
|
case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
|
|
729
729
|
throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
|
|
730
|
-
case "
|
|
730
|
+
case "PriorityInUse":
|
|
731
731
|
case "com.amazonaws.elasticloadbalancingv2#PriorityInUseException":
|
|
732
732
|
throw await deserializeAws_queryPriorityInUseExceptionResponse(parsedOutput, context);
|
|
733
|
-
case "
|
|
733
|
+
case "TargetGroupAssociationLimit":
|
|
734
734
|
case "com.amazonaws.elasticloadbalancingv2#TargetGroupAssociationLimitException":
|
|
735
735
|
throw await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context);
|
|
736
|
-
case "
|
|
736
|
+
case "TargetGroupNotFound":
|
|
737
737
|
case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
|
|
738
738
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
739
|
-
case "
|
|
739
|
+
case "TooManyActions":
|
|
740
740
|
case "com.amazonaws.elasticloadbalancingv2#TooManyActionsException":
|
|
741
741
|
throw await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context);
|
|
742
|
-
case "
|
|
742
|
+
case "TooManyRegistrationsForTargetId":
|
|
743
743
|
case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
|
|
744
744
|
throw await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context);
|
|
745
|
-
case "
|
|
745
|
+
case "TooManyRules":
|
|
746
746
|
case "com.amazonaws.elasticloadbalancingv2#TooManyRulesException":
|
|
747
747
|
throw await deserializeAws_queryTooManyRulesExceptionResponse(parsedOutput, context);
|
|
748
|
-
case "
|
|
748
|
+
case "TooManyTags":
|
|
749
749
|
case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
|
|
750
750
|
throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
|
|
751
|
-
case "
|
|
751
|
+
case "TooManyTargetGroups":
|
|
752
752
|
case "com.amazonaws.elasticloadbalancingv2#TooManyTargetGroupsException":
|
|
753
753
|
throw await deserializeAws_queryTooManyTargetGroupsExceptionResponse(parsedOutput, context);
|
|
754
|
-
case "
|
|
754
|
+
case "TooManyTargets":
|
|
755
755
|
case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
|
|
756
756
|
throw await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context);
|
|
757
|
-
case "
|
|
757
|
+
case "TooManyUniqueTargetGroupsPerLoadBalancer":
|
|
758
758
|
case "com.amazonaws.elasticloadbalancingv2#TooManyUniqueTargetGroupsPerLoadBalancerException":
|
|
759
759
|
throw await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context);
|
|
760
|
-
case "
|
|
760
|
+
case "UnsupportedProtocol":
|
|
761
761
|
case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
|
|
762
762
|
throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
|
|
763
763
|
default:
|
|
@@ -787,20 +787,20 @@ exports.deserializeAws_queryCreateTargetGroupCommand = deserializeAws_queryCreat
|
|
|
787
787
|
const deserializeAws_queryCreateTargetGroupCommandError = async (output, context) => {
|
|
788
788
|
const parsedOutput = {
|
|
789
789
|
...output,
|
|
790
|
-
body: await
|
|
790
|
+
body: await parseErrorBody(output.body, context),
|
|
791
791
|
};
|
|
792
792
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
793
793
|
switch (errorCode) {
|
|
794
|
-
case "
|
|
794
|
+
case "DuplicateTargetGroupName":
|
|
795
795
|
case "com.amazonaws.elasticloadbalancingv2#DuplicateTargetGroupNameException":
|
|
796
796
|
throw await deserializeAws_queryDuplicateTargetGroupNameExceptionResponse(parsedOutput, context);
|
|
797
|
-
case "
|
|
797
|
+
case "InvalidConfigurationRequest":
|
|
798
798
|
case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
|
|
799
799
|
throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
|
|
800
|
-
case "
|
|
800
|
+
case "TooManyTags":
|
|
801
801
|
case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
|
|
802
802
|
throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
|
|
803
|
-
case "
|
|
803
|
+
case "TooManyTargetGroups":
|
|
804
804
|
case "com.amazonaws.elasticloadbalancingv2#TooManyTargetGroupsException":
|
|
805
805
|
throw await deserializeAws_queryTooManyTargetGroupsExceptionResponse(parsedOutput, context);
|
|
806
806
|
default:
|
|
@@ -830,14 +830,14 @@ exports.deserializeAws_queryDeleteListenerCommand = deserializeAws_queryDeleteLi
|
|
|
830
830
|
const deserializeAws_queryDeleteListenerCommandError = async (output, context) => {
|
|
831
831
|
const parsedOutput = {
|
|
832
832
|
...output,
|
|
833
|
-
body: await
|
|
833
|
+
body: await parseErrorBody(output.body, context),
|
|
834
834
|
};
|
|
835
835
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
836
836
|
switch (errorCode) {
|
|
837
|
-
case "
|
|
837
|
+
case "ListenerNotFound":
|
|
838
838
|
case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
|
|
839
839
|
throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
|
|
840
|
-
case "
|
|
840
|
+
case "ResourceInUse":
|
|
841
841
|
case "com.amazonaws.elasticloadbalancingv2#ResourceInUseException":
|
|
842
842
|
throw await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context);
|
|
843
843
|
default:
|
|
@@ -867,17 +867,17 @@ exports.deserializeAws_queryDeleteLoadBalancerCommand = deserializeAws_queryDele
|
|
|
867
867
|
const deserializeAws_queryDeleteLoadBalancerCommandError = async (output, context) => {
|
|
868
868
|
const parsedOutput = {
|
|
869
869
|
...output,
|
|
870
|
-
body: await
|
|
870
|
+
body: await parseErrorBody(output.body, context),
|
|
871
871
|
};
|
|
872
872
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
873
873
|
switch (errorCode) {
|
|
874
|
-
case "
|
|
874
|
+
case "LoadBalancerNotFound":
|
|
875
875
|
case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
|
|
876
876
|
throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
|
|
877
|
-
case "
|
|
877
|
+
case "OperationNotPermitted":
|
|
878
878
|
case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
|
|
879
879
|
throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
|
|
880
|
-
case "
|
|
880
|
+
case "ResourceInUse":
|
|
881
881
|
case "com.amazonaws.elasticloadbalancingv2#ResourceInUseException":
|
|
882
882
|
throw await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context);
|
|
883
883
|
default:
|
|
@@ -907,14 +907,14 @@ exports.deserializeAws_queryDeleteRuleCommand = deserializeAws_queryDeleteRuleCo
|
|
|
907
907
|
const deserializeAws_queryDeleteRuleCommandError = async (output, context) => {
|
|
908
908
|
const parsedOutput = {
|
|
909
909
|
...output,
|
|
910
|
-
body: await
|
|
910
|
+
body: await parseErrorBody(output.body, context),
|
|
911
911
|
};
|
|
912
912
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
913
913
|
switch (errorCode) {
|
|
914
|
-
case "
|
|
914
|
+
case "OperationNotPermitted":
|
|
915
915
|
case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
|
|
916
916
|
throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
|
|
917
|
-
case "
|
|
917
|
+
case "RuleNotFound":
|
|
918
918
|
case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
|
|
919
919
|
throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
|
|
920
920
|
default:
|
|
@@ -944,11 +944,11 @@ exports.deserializeAws_queryDeleteTargetGroupCommand = deserializeAws_queryDelet
|
|
|
944
944
|
const deserializeAws_queryDeleteTargetGroupCommandError = async (output, context) => {
|
|
945
945
|
const parsedOutput = {
|
|
946
946
|
...output,
|
|
947
|
-
body: await
|
|
947
|
+
body: await parseErrorBody(output.body, context),
|
|
948
948
|
};
|
|
949
949
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
950
950
|
switch (errorCode) {
|
|
951
|
-
case "
|
|
951
|
+
case "ResourceInUse":
|
|
952
952
|
case "com.amazonaws.elasticloadbalancingv2#ResourceInUseException":
|
|
953
953
|
throw await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context);
|
|
954
954
|
default:
|
|
@@ -978,14 +978,14 @@ exports.deserializeAws_queryDeregisterTargetsCommand = deserializeAws_queryDereg
|
|
|
978
978
|
const deserializeAws_queryDeregisterTargetsCommandError = async (output, context) => {
|
|
979
979
|
const parsedOutput = {
|
|
980
980
|
...output,
|
|
981
|
-
body: await
|
|
981
|
+
body: await parseErrorBody(output.body, context),
|
|
982
982
|
};
|
|
983
983
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
984
984
|
switch (errorCode) {
|
|
985
|
-
case "
|
|
985
|
+
case "InvalidTarget":
|
|
986
986
|
case "com.amazonaws.elasticloadbalancingv2#InvalidTargetException":
|
|
987
987
|
throw await deserializeAws_queryInvalidTargetExceptionResponse(parsedOutput, context);
|
|
988
|
-
case "
|
|
988
|
+
case "TargetGroupNotFound":
|
|
989
989
|
case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
|
|
990
990
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
991
991
|
default:
|
|
@@ -1015,7 +1015,7 @@ exports.deserializeAws_queryDescribeAccountLimitsCommand = deserializeAws_queryD
|
|
|
1015
1015
|
const deserializeAws_queryDescribeAccountLimitsCommandError = async (output, context) => {
|
|
1016
1016
|
const parsedOutput = {
|
|
1017
1017
|
...output,
|
|
1018
|
-
body: await
|
|
1018
|
+
body: await parseErrorBody(output.body, context),
|
|
1019
1019
|
};
|
|
1020
1020
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1021
1021
|
const parsedBody = parsedOutput.body;
|
|
@@ -1043,11 +1043,11 @@ exports.deserializeAws_queryDescribeListenerCertificatesCommand = deserializeAws
|
|
|
1043
1043
|
const deserializeAws_queryDescribeListenerCertificatesCommandError = async (output, context) => {
|
|
1044
1044
|
const parsedOutput = {
|
|
1045
1045
|
...output,
|
|
1046
|
-
body: await
|
|
1046
|
+
body: await parseErrorBody(output.body, context),
|
|
1047
1047
|
};
|
|
1048
1048
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1049
1049
|
switch (errorCode) {
|
|
1050
|
-
case "
|
|
1050
|
+
case "ListenerNotFound":
|
|
1051
1051
|
case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
|
|
1052
1052
|
throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
|
|
1053
1053
|
default:
|
|
@@ -1077,17 +1077,17 @@ exports.deserializeAws_queryDescribeListenersCommand = deserializeAws_queryDescr
|
|
|
1077
1077
|
const deserializeAws_queryDescribeListenersCommandError = async (output, context) => {
|
|
1078
1078
|
const parsedOutput = {
|
|
1079
1079
|
...output,
|
|
1080
|
-
body: await
|
|
1080
|
+
body: await parseErrorBody(output.body, context),
|
|
1081
1081
|
};
|
|
1082
1082
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1083
1083
|
switch (errorCode) {
|
|
1084
|
-
case "
|
|
1084
|
+
case "ListenerNotFound":
|
|
1085
1085
|
case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
|
|
1086
1086
|
throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
|
|
1087
|
-
case "
|
|
1087
|
+
case "LoadBalancerNotFound":
|
|
1088
1088
|
case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
|
|
1089
1089
|
throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
|
|
1090
|
-
case "
|
|
1090
|
+
case "UnsupportedProtocol":
|
|
1091
1091
|
case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
|
|
1092
1092
|
throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
|
|
1093
1093
|
default:
|
|
@@ -1117,11 +1117,11 @@ exports.deserializeAws_queryDescribeLoadBalancerAttributesCommand = deserializeA
|
|
|
1117
1117
|
const deserializeAws_queryDescribeLoadBalancerAttributesCommandError = async (output, context) => {
|
|
1118
1118
|
const parsedOutput = {
|
|
1119
1119
|
...output,
|
|
1120
|
-
body: await
|
|
1120
|
+
body: await parseErrorBody(output.body, context),
|
|
1121
1121
|
};
|
|
1122
1122
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1123
1123
|
switch (errorCode) {
|
|
1124
|
-
case "
|
|
1124
|
+
case "LoadBalancerNotFound":
|
|
1125
1125
|
case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
|
|
1126
1126
|
throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
|
|
1127
1127
|
default:
|
|
@@ -1151,11 +1151,11 @@ exports.deserializeAws_queryDescribeLoadBalancersCommand = deserializeAws_queryD
|
|
|
1151
1151
|
const deserializeAws_queryDescribeLoadBalancersCommandError = async (output, context) => {
|
|
1152
1152
|
const parsedOutput = {
|
|
1153
1153
|
...output,
|
|
1154
|
-
body: await
|
|
1154
|
+
body: await parseErrorBody(output.body, context),
|
|
1155
1155
|
};
|
|
1156
1156
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1157
1157
|
switch (errorCode) {
|
|
1158
|
-
case "
|
|
1158
|
+
case "LoadBalancerNotFound":
|
|
1159
1159
|
case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
|
|
1160
1160
|
throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
|
|
1161
1161
|
default:
|
|
@@ -1185,17 +1185,17 @@ exports.deserializeAws_queryDescribeRulesCommand = deserializeAws_queryDescribeR
|
|
|
1185
1185
|
const deserializeAws_queryDescribeRulesCommandError = async (output, context) => {
|
|
1186
1186
|
const parsedOutput = {
|
|
1187
1187
|
...output,
|
|
1188
|
-
body: await
|
|
1188
|
+
body: await parseErrorBody(output.body, context),
|
|
1189
1189
|
};
|
|
1190
1190
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1191
1191
|
switch (errorCode) {
|
|
1192
|
-
case "
|
|
1192
|
+
case "ListenerNotFound":
|
|
1193
1193
|
case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
|
|
1194
1194
|
throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
|
|
1195
|
-
case "
|
|
1195
|
+
case "RuleNotFound":
|
|
1196
1196
|
case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
|
|
1197
1197
|
throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
|
|
1198
|
-
case "
|
|
1198
|
+
case "UnsupportedProtocol":
|
|
1199
1199
|
case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
|
|
1200
1200
|
throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
|
|
1201
1201
|
default:
|
|
@@ -1225,11 +1225,11 @@ exports.deserializeAws_queryDescribeSSLPoliciesCommand = deserializeAws_queryDes
|
|
|
1225
1225
|
const deserializeAws_queryDescribeSSLPoliciesCommandError = async (output, context) => {
|
|
1226
1226
|
const parsedOutput = {
|
|
1227
1227
|
...output,
|
|
1228
|
-
body: await
|
|
1228
|
+
body: await parseErrorBody(output.body, context),
|
|
1229
1229
|
};
|
|
1230
1230
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1231
1231
|
switch (errorCode) {
|
|
1232
|
-
case "
|
|
1232
|
+
case "SSLPolicyNotFound":
|
|
1233
1233
|
case "com.amazonaws.elasticloadbalancingv2#SSLPolicyNotFoundException":
|
|
1234
1234
|
throw await deserializeAws_querySSLPolicyNotFoundExceptionResponse(parsedOutput, context);
|
|
1235
1235
|
default:
|
|
@@ -1259,20 +1259,20 @@ exports.deserializeAws_queryDescribeTagsCommand = deserializeAws_queryDescribeTa
|
|
|
1259
1259
|
const deserializeAws_queryDescribeTagsCommandError = async (output, context) => {
|
|
1260
1260
|
const parsedOutput = {
|
|
1261
1261
|
...output,
|
|
1262
|
-
body: await
|
|
1262
|
+
body: await parseErrorBody(output.body, context),
|
|
1263
1263
|
};
|
|
1264
1264
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1265
1265
|
switch (errorCode) {
|
|
1266
|
-
case "
|
|
1266
|
+
case "ListenerNotFound":
|
|
1267
1267
|
case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
|
|
1268
1268
|
throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
|
|
1269
|
-
case "
|
|
1269
|
+
case "LoadBalancerNotFound":
|
|
1270
1270
|
case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
|
|
1271
1271
|
throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
|
|
1272
|
-
case "
|
|
1272
|
+
case "RuleNotFound":
|
|
1273
1273
|
case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
|
|
1274
1274
|
throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
|
|
1275
|
-
case "
|
|
1275
|
+
case "TargetGroupNotFound":
|
|
1276
1276
|
case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
|
|
1277
1277
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
1278
1278
|
default:
|
|
@@ -1302,11 +1302,11 @@ exports.deserializeAws_queryDescribeTargetGroupAttributesCommand = deserializeAw
|
|
|
1302
1302
|
const deserializeAws_queryDescribeTargetGroupAttributesCommandError = async (output, context) => {
|
|
1303
1303
|
const parsedOutput = {
|
|
1304
1304
|
...output,
|
|
1305
|
-
body: await
|
|
1305
|
+
body: await parseErrorBody(output.body, context),
|
|
1306
1306
|
};
|
|
1307
1307
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1308
1308
|
switch (errorCode) {
|
|
1309
|
-
case "
|
|
1309
|
+
case "TargetGroupNotFound":
|
|
1310
1310
|
case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
|
|
1311
1311
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
1312
1312
|
default:
|
|
@@ -1336,14 +1336,14 @@ exports.deserializeAws_queryDescribeTargetGroupsCommand = deserializeAws_queryDe
|
|
|
1336
1336
|
const deserializeAws_queryDescribeTargetGroupsCommandError = async (output, context) => {
|
|
1337
1337
|
const parsedOutput = {
|
|
1338
1338
|
...output,
|
|
1339
|
-
body: await
|
|
1339
|
+
body: await parseErrorBody(output.body, context),
|
|
1340
1340
|
};
|
|
1341
1341
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1342
1342
|
switch (errorCode) {
|
|
1343
|
-
case "
|
|
1343
|
+
case "LoadBalancerNotFound":
|
|
1344
1344
|
case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
|
|
1345
1345
|
throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
|
|
1346
|
-
case "
|
|
1346
|
+
case "TargetGroupNotFound":
|
|
1347
1347
|
case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
|
|
1348
1348
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
1349
1349
|
default:
|
|
@@ -1373,17 +1373,17 @@ exports.deserializeAws_queryDescribeTargetHealthCommand = deserializeAws_queryDe
|
|
|
1373
1373
|
const deserializeAws_queryDescribeTargetHealthCommandError = async (output, context) => {
|
|
1374
1374
|
const parsedOutput = {
|
|
1375
1375
|
...output,
|
|
1376
|
-
body: await
|
|
1376
|
+
body: await parseErrorBody(output.body, context),
|
|
1377
1377
|
};
|
|
1378
1378
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1379
1379
|
switch (errorCode) {
|
|
1380
|
-
case "
|
|
1380
|
+
case "HealthUnavailable":
|
|
1381
1381
|
case "com.amazonaws.elasticloadbalancingv2#HealthUnavailableException":
|
|
1382
1382
|
throw await deserializeAws_queryHealthUnavailableExceptionResponse(parsedOutput, context);
|
|
1383
|
-
case "
|
|
1383
|
+
case "InvalidTarget":
|
|
1384
1384
|
case "com.amazonaws.elasticloadbalancingv2#InvalidTargetException":
|
|
1385
1385
|
throw await deserializeAws_queryInvalidTargetExceptionResponse(parsedOutput, context);
|
|
1386
|
-
case "
|
|
1386
|
+
case "TargetGroupNotFound":
|
|
1387
1387
|
case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
|
|
1388
1388
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
1389
1389
|
default:
|
|
@@ -1413,59 +1413,59 @@ exports.deserializeAws_queryModifyListenerCommand = deserializeAws_queryModifyLi
|
|
|
1413
1413
|
const deserializeAws_queryModifyListenerCommandError = async (output, context) => {
|
|
1414
1414
|
const parsedOutput = {
|
|
1415
1415
|
...output,
|
|
1416
|
-
body: await
|
|
1416
|
+
body: await parseErrorBody(output.body, context),
|
|
1417
1417
|
};
|
|
1418
1418
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1419
1419
|
switch (errorCode) {
|
|
1420
|
-
case "
|
|
1420
|
+
case "ALPNPolicyNotFound":
|
|
1421
1421
|
case "com.amazonaws.elasticloadbalancingv2#ALPNPolicyNotSupportedException":
|
|
1422
1422
|
throw await deserializeAws_queryALPNPolicyNotSupportedExceptionResponse(parsedOutput, context);
|
|
1423
|
-
case "
|
|
1423
|
+
case "CertificateNotFound":
|
|
1424
1424
|
case "com.amazonaws.elasticloadbalancingv2#CertificateNotFoundException":
|
|
1425
1425
|
throw await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context);
|
|
1426
|
-
case "
|
|
1426
|
+
case "DuplicateListener":
|
|
1427
1427
|
case "com.amazonaws.elasticloadbalancingv2#DuplicateListenerException":
|
|
1428
1428
|
throw await deserializeAws_queryDuplicateListenerExceptionResponse(parsedOutput, context);
|
|
1429
|
-
case "
|
|
1429
|
+
case "IncompatibleProtocols":
|
|
1430
1430
|
case "com.amazonaws.elasticloadbalancingv2#IncompatibleProtocolsException":
|
|
1431
1431
|
throw await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context);
|
|
1432
|
-
case "
|
|
1432
|
+
case "InvalidConfigurationRequest":
|
|
1433
1433
|
case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
|
|
1434
1434
|
throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
|
|
1435
|
-
case "
|
|
1435
|
+
case "InvalidLoadBalancerAction":
|
|
1436
1436
|
case "com.amazonaws.elasticloadbalancingv2#InvalidLoadBalancerActionException":
|
|
1437
1437
|
throw await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context);
|
|
1438
|
-
case "
|
|
1438
|
+
case "ListenerNotFound":
|
|
1439
1439
|
case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
|
|
1440
1440
|
throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
|
|
1441
|
-
case "
|
|
1441
|
+
case "SSLPolicyNotFound":
|
|
1442
1442
|
case "com.amazonaws.elasticloadbalancingv2#SSLPolicyNotFoundException":
|
|
1443
1443
|
throw await deserializeAws_querySSLPolicyNotFoundExceptionResponse(parsedOutput, context);
|
|
1444
|
-
case "
|
|
1444
|
+
case "TargetGroupAssociationLimit":
|
|
1445
1445
|
case "com.amazonaws.elasticloadbalancingv2#TargetGroupAssociationLimitException":
|
|
1446
1446
|
throw await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context);
|
|
1447
|
-
case "
|
|
1447
|
+
case "TargetGroupNotFound":
|
|
1448
1448
|
case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
|
|
1449
1449
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
1450
|
-
case "
|
|
1450
|
+
case "TooManyActions":
|
|
1451
1451
|
case "com.amazonaws.elasticloadbalancingv2#TooManyActionsException":
|
|
1452
1452
|
throw await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context);
|
|
1453
|
-
case "
|
|
1453
|
+
case "TooManyCertificates":
|
|
1454
1454
|
case "com.amazonaws.elasticloadbalancingv2#TooManyCertificatesException":
|
|
1455
1455
|
throw await deserializeAws_queryTooManyCertificatesExceptionResponse(parsedOutput, context);
|
|
1456
|
-
case "
|
|
1456
|
+
case "TooManyListeners":
|
|
1457
1457
|
case "com.amazonaws.elasticloadbalancingv2#TooManyListenersException":
|
|
1458
1458
|
throw await deserializeAws_queryTooManyListenersExceptionResponse(parsedOutput, context);
|
|
1459
|
-
case "
|
|
1459
|
+
case "TooManyRegistrationsForTargetId":
|
|
1460
1460
|
case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
|
|
1461
1461
|
throw await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context);
|
|
1462
|
-
case "
|
|
1462
|
+
case "TooManyTargets":
|
|
1463
1463
|
case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
|
|
1464
1464
|
throw await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context);
|
|
1465
|
-
case "
|
|
1465
|
+
case "TooManyUniqueTargetGroupsPerLoadBalancer":
|
|
1466
1466
|
case "com.amazonaws.elasticloadbalancingv2#TooManyUniqueTargetGroupsPerLoadBalancerException":
|
|
1467
1467
|
throw await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context);
|
|
1468
|
-
case "
|
|
1468
|
+
case "UnsupportedProtocol":
|
|
1469
1469
|
case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
|
|
1470
1470
|
throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
|
|
1471
1471
|
default:
|
|
@@ -1495,14 +1495,14 @@ exports.deserializeAws_queryModifyLoadBalancerAttributesCommand = deserializeAws
|
|
|
1495
1495
|
const deserializeAws_queryModifyLoadBalancerAttributesCommandError = async (output, context) => {
|
|
1496
1496
|
const parsedOutput = {
|
|
1497
1497
|
...output,
|
|
1498
|
-
body: await
|
|
1498
|
+
body: await parseErrorBody(output.body, context),
|
|
1499
1499
|
};
|
|
1500
1500
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1501
1501
|
switch (errorCode) {
|
|
1502
|
-
case "
|
|
1502
|
+
case "InvalidConfigurationRequest":
|
|
1503
1503
|
case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
|
|
1504
1504
|
throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
|
|
1505
|
-
case "
|
|
1505
|
+
case "LoadBalancerNotFound":
|
|
1506
1506
|
case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
|
|
1507
1507
|
throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
|
|
1508
1508
|
default:
|
|
@@ -1532,41 +1532,41 @@ exports.deserializeAws_queryModifyRuleCommand = deserializeAws_queryModifyRuleCo
|
|
|
1532
1532
|
const deserializeAws_queryModifyRuleCommandError = async (output, context) => {
|
|
1533
1533
|
const parsedOutput = {
|
|
1534
1534
|
...output,
|
|
1535
|
-
body: await
|
|
1535
|
+
body: await parseErrorBody(output.body, context),
|
|
1536
1536
|
};
|
|
1537
1537
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1538
1538
|
switch (errorCode) {
|
|
1539
|
-
case "
|
|
1539
|
+
case "IncompatibleProtocols":
|
|
1540
1540
|
case "com.amazonaws.elasticloadbalancingv2#IncompatibleProtocolsException":
|
|
1541
1541
|
throw await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context);
|
|
1542
|
-
case "
|
|
1542
|
+
case "InvalidLoadBalancerAction":
|
|
1543
1543
|
case "com.amazonaws.elasticloadbalancingv2#InvalidLoadBalancerActionException":
|
|
1544
1544
|
throw await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context);
|
|
1545
|
-
case "
|
|
1545
|
+
case "OperationNotPermitted":
|
|
1546
1546
|
case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
|
|
1547
1547
|
throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
|
|
1548
|
-
case "
|
|
1548
|
+
case "RuleNotFound":
|
|
1549
1549
|
case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
|
|
1550
1550
|
throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
|
|
1551
|
-
case "
|
|
1551
|
+
case "TargetGroupAssociationLimit":
|
|
1552
1552
|
case "com.amazonaws.elasticloadbalancingv2#TargetGroupAssociationLimitException":
|
|
1553
1553
|
throw await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context);
|
|
1554
|
-
case "
|
|
1554
|
+
case "TargetGroupNotFound":
|
|
1555
1555
|
case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
|
|
1556
1556
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
1557
|
-
case "
|
|
1557
|
+
case "TooManyActions":
|
|
1558
1558
|
case "com.amazonaws.elasticloadbalancingv2#TooManyActionsException":
|
|
1559
1559
|
throw await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context);
|
|
1560
|
-
case "
|
|
1560
|
+
case "TooManyRegistrationsForTargetId":
|
|
1561
1561
|
case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
|
|
1562
1562
|
throw await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context);
|
|
1563
|
-
case "
|
|
1563
|
+
case "TooManyTargets":
|
|
1564
1564
|
case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
|
|
1565
1565
|
throw await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context);
|
|
1566
|
-
case "
|
|
1566
|
+
case "TooManyUniqueTargetGroupsPerLoadBalancer":
|
|
1567
1567
|
case "com.amazonaws.elasticloadbalancingv2#TooManyUniqueTargetGroupsPerLoadBalancerException":
|
|
1568
1568
|
throw await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context);
|
|
1569
|
-
case "
|
|
1569
|
+
case "UnsupportedProtocol":
|
|
1570
1570
|
case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
|
|
1571
1571
|
throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
|
|
1572
1572
|
default:
|
|
@@ -1596,14 +1596,14 @@ exports.deserializeAws_queryModifyTargetGroupCommand = deserializeAws_queryModif
|
|
|
1596
1596
|
const deserializeAws_queryModifyTargetGroupCommandError = async (output, context) => {
|
|
1597
1597
|
const parsedOutput = {
|
|
1598
1598
|
...output,
|
|
1599
|
-
body: await
|
|
1599
|
+
body: await parseErrorBody(output.body, context),
|
|
1600
1600
|
};
|
|
1601
1601
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1602
1602
|
switch (errorCode) {
|
|
1603
|
-
case "
|
|
1603
|
+
case "InvalidConfigurationRequest":
|
|
1604
1604
|
case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
|
|
1605
1605
|
throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
|
|
1606
|
-
case "
|
|
1606
|
+
case "TargetGroupNotFound":
|
|
1607
1607
|
case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
|
|
1608
1608
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
1609
1609
|
default:
|
|
@@ -1633,14 +1633,14 @@ exports.deserializeAws_queryModifyTargetGroupAttributesCommand = deserializeAws_
|
|
|
1633
1633
|
const deserializeAws_queryModifyTargetGroupAttributesCommandError = async (output, context) => {
|
|
1634
1634
|
const parsedOutput = {
|
|
1635
1635
|
...output,
|
|
1636
|
-
body: await
|
|
1636
|
+
body: await parseErrorBody(output.body, context),
|
|
1637
1637
|
};
|
|
1638
1638
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1639
1639
|
switch (errorCode) {
|
|
1640
|
-
case "
|
|
1640
|
+
case "InvalidConfigurationRequest":
|
|
1641
1641
|
case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
|
|
1642
1642
|
throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
|
|
1643
|
-
case "
|
|
1643
|
+
case "TargetGroupNotFound":
|
|
1644
1644
|
case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
|
|
1645
1645
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
1646
1646
|
default:
|
|
@@ -1670,20 +1670,20 @@ exports.deserializeAws_queryRegisterTargetsCommand = deserializeAws_queryRegiste
|
|
|
1670
1670
|
const deserializeAws_queryRegisterTargetsCommandError = async (output, context) => {
|
|
1671
1671
|
const parsedOutput = {
|
|
1672
1672
|
...output,
|
|
1673
|
-
body: await
|
|
1673
|
+
body: await parseErrorBody(output.body, context),
|
|
1674
1674
|
};
|
|
1675
1675
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1676
1676
|
switch (errorCode) {
|
|
1677
|
-
case "
|
|
1677
|
+
case "InvalidTarget":
|
|
1678
1678
|
case "com.amazonaws.elasticloadbalancingv2#InvalidTargetException":
|
|
1679
1679
|
throw await deserializeAws_queryInvalidTargetExceptionResponse(parsedOutput, context);
|
|
1680
|
-
case "
|
|
1680
|
+
case "TargetGroupNotFound":
|
|
1681
1681
|
case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
|
|
1682
1682
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
1683
|
-
case "
|
|
1683
|
+
case "TooManyRegistrationsForTargetId":
|
|
1684
1684
|
case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
|
|
1685
1685
|
throw await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context);
|
|
1686
|
-
case "
|
|
1686
|
+
case "TooManyTargets":
|
|
1687
1687
|
case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
|
|
1688
1688
|
throw await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context);
|
|
1689
1689
|
default:
|
|
@@ -1713,14 +1713,14 @@ exports.deserializeAws_queryRemoveListenerCertificatesCommand = deserializeAws_q
|
|
|
1713
1713
|
const deserializeAws_queryRemoveListenerCertificatesCommandError = async (output, context) => {
|
|
1714
1714
|
const parsedOutput = {
|
|
1715
1715
|
...output,
|
|
1716
|
-
body: await
|
|
1716
|
+
body: await parseErrorBody(output.body, context),
|
|
1717
1717
|
};
|
|
1718
1718
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1719
1719
|
switch (errorCode) {
|
|
1720
|
-
case "
|
|
1720
|
+
case "ListenerNotFound":
|
|
1721
1721
|
case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
|
|
1722
1722
|
throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
|
|
1723
|
-
case "
|
|
1723
|
+
case "OperationNotPermitted":
|
|
1724
1724
|
case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
|
|
1725
1725
|
throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
|
|
1726
1726
|
default:
|
|
@@ -1750,23 +1750,23 @@ exports.deserializeAws_queryRemoveTagsCommand = deserializeAws_queryRemoveTagsCo
|
|
|
1750
1750
|
const deserializeAws_queryRemoveTagsCommandError = async (output, context) => {
|
|
1751
1751
|
const parsedOutput = {
|
|
1752
1752
|
...output,
|
|
1753
|
-
body: await
|
|
1753
|
+
body: await parseErrorBody(output.body, context),
|
|
1754
1754
|
};
|
|
1755
1755
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1756
1756
|
switch (errorCode) {
|
|
1757
|
-
case "
|
|
1757
|
+
case "ListenerNotFound":
|
|
1758
1758
|
case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
|
|
1759
1759
|
throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
|
|
1760
|
-
case "
|
|
1760
|
+
case "LoadBalancerNotFound":
|
|
1761
1761
|
case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
|
|
1762
1762
|
throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
|
|
1763
|
-
case "
|
|
1763
|
+
case "RuleNotFound":
|
|
1764
1764
|
case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
|
|
1765
1765
|
throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
|
|
1766
|
-
case "
|
|
1766
|
+
case "TargetGroupNotFound":
|
|
1767
1767
|
case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
|
|
1768
1768
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
1769
|
-
case "
|
|
1769
|
+
case "TooManyTags":
|
|
1770
1770
|
case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
|
|
1771
1771
|
throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
|
|
1772
1772
|
default:
|
|
@@ -1796,17 +1796,17 @@ exports.deserializeAws_querySetIpAddressTypeCommand = deserializeAws_querySetIpA
|
|
|
1796
1796
|
const deserializeAws_querySetIpAddressTypeCommandError = async (output, context) => {
|
|
1797
1797
|
const parsedOutput = {
|
|
1798
1798
|
...output,
|
|
1799
|
-
body: await
|
|
1799
|
+
body: await parseErrorBody(output.body, context),
|
|
1800
1800
|
};
|
|
1801
1801
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1802
1802
|
switch (errorCode) {
|
|
1803
|
-
case "
|
|
1803
|
+
case "InvalidConfigurationRequest":
|
|
1804
1804
|
case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
|
|
1805
1805
|
throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
|
|
1806
|
-
case "
|
|
1806
|
+
case "InvalidSubnet":
|
|
1807
1807
|
case "com.amazonaws.elasticloadbalancingv2#InvalidSubnetException":
|
|
1808
1808
|
throw await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context);
|
|
1809
|
-
case "
|
|
1809
|
+
case "LoadBalancerNotFound":
|
|
1810
1810
|
case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
|
|
1811
1811
|
throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
|
|
1812
1812
|
default:
|
|
@@ -1836,17 +1836,17 @@ exports.deserializeAws_querySetRulePrioritiesCommand = deserializeAws_querySetRu
|
|
|
1836
1836
|
const deserializeAws_querySetRulePrioritiesCommandError = async (output, context) => {
|
|
1837
1837
|
const parsedOutput = {
|
|
1838
1838
|
...output,
|
|
1839
|
-
body: await
|
|
1839
|
+
body: await parseErrorBody(output.body, context),
|
|
1840
1840
|
};
|
|
1841
1841
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1842
1842
|
switch (errorCode) {
|
|
1843
|
-
case "
|
|
1843
|
+
case "OperationNotPermitted":
|
|
1844
1844
|
case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
|
|
1845
1845
|
throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
|
|
1846
|
-
case "
|
|
1846
|
+
case "PriorityInUse":
|
|
1847
1847
|
case "com.amazonaws.elasticloadbalancingv2#PriorityInUseException":
|
|
1848
1848
|
throw await deserializeAws_queryPriorityInUseExceptionResponse(parsedOutput, context);
|
|
1849
|
-
case "
|
|
1849
|
+
case "RuleNotFound":
|
|
1850
1850
|
case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
|
|
1851
1851
|
throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
|
|
1852
1852
|
default:
|
|
@@ -1876,17 +1876,17 @@ exports.deserializeAws_querySetSecurityGroupsCommand = deserializeAws_querySetSe
|
|
|
1876
1876
|
const deserializeAws_querySetSecurityGroupsCommandError = async (output, context) => {
|
|
1877
1877
|
const parsedOutput = {
|
|
1878
1878
|
...output,
|
|
1879
|
-
body: await
|
|
1879
|
+
body: await parseErrorBody(output.body, context),
|
|
1880
1880
|
};
|
|
1881
1881
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1882
1882
|
switch (errorCode) {
|
|
1883
|
-
case "
|
|
1883
|
+
case "InvalidConfigurationRequest":
|
|
1884
1884
|
case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
|
|
1885
1885
|
throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
|
|
1886
|
-
case "
|
|
1886
|
+
case "InvalidSecurityGroup":
|
|
1887
1887
|
case "com.amazonaws.elasticloadbalancingv2#InvalidSecurityGroupException":
|
|
1888
1888
|
throw await deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context);
|
|
1889
|
-
case "
|
|
1889
|
+
case "LoadBalancerNotFound":
|
|
1890
1890
|
case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
|
|
1891
1891
|
throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
|
|
1892
1892
|
default:
|
|
@@ -1916,26 +1916,26 @@ exports.deserializeAws_querySetSubnetsCommand = deserializeAws_querySetSubnetsCo
|
|
|
1916
1916
|
const deserializeAws_querySetSubnetsCommandError = async (output, context) => {
|
|
1917
1917
|
const parsedOutput = {
|
|
1918
1918
|
...output,
|
|
1919
|
-
body: await
|
|
1919
|
+
body: await parseErrorBody(output.body, context),
|
|
1920
1920
|
};
|
|
1921
1921
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1922
1922
|
switch (errorCode) {
|
|
1923
|
-
case "
|
|
1923
|
+
case "AllocationIdNotFound":
|
|
1924
1924
|
case "com.amazonaws.elasticloadbalancingv2#AllocationIdNotFoundException":
|
|
1925
1925
|
throw await deserializeAws_queryAllocationIdNotFoundExceptionResponse(parsedOutput, context);
|
|
1926
|
-
case "
|
|
1926
|
+
case "AvailabilityZoneNotSupported":
|
|
1927
1927
|
case "com.amazonaws.elasticloadbalancingv2#AvailabilityZoneNotSupportedException":
|
|
1928
1928
|
throw await deserializeAws_queryAvailabilityZoneNotSupportedExceptionResponse(parsedOutput, context);
|
|
1929
|
-
case "
|
|
1929
|
+
case "InvalidConfigurationRequest":
|
|
1930
1930
|
case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
|
|
1931
1931
|
throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
|
|
1932
|
-
case "
|
|
1932
|
+
case "InvalidSubnet":
|
|
1933
1933
|
case "com.amazonaws.elasticloadbalancingv2#InvalidSubnetException":
|
|
1934
1934
|
throw await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context);
|
|
1935
|
-
case "
|
|
1935
|
+
case "LoadBalancerNotFound":
|
|
1936
1936
|
case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
|
|
1937
1937
|
throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
|
|
1938
|
-
case "
|
|
1938
|
+
case "SubnetNotFound":
|
|
1939
1939
|
case "com.amazonaws.elasticloadbalancingv2#SubnetNotFoundException":
|
|
1940
1940
|
throw await deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context);
|
|
1941
1941
|
default:
|
|
@@ -5472,6 +5472,14 @@ const parseBody = (streamBody, context) => collectBodyString(streamBody, context
|
|
|
5472
5472
|
}
|
|
5473
5473
|
return {};
|
|
5474
5474
|
});
|
|
5475
|
+
const parseErrorBody = async (errorBody, context) => {
|
|
5476
|
+
var _a;
|
|
5477
|
+
const value = await parseBody(errorBody, context);
|
|
5478
|
+
if (value.Error) {
|
|
5479
|
+
value.Error.message = (_a = value.Error.message) !== null && _a !== void 0 ? _a : value.Error.Message;
|
|
5480
|
+
}
|
|
5481
|
+
return value;
|
|
5482
|
+
};
|
|
5475
5483
|
const buildFormUrlencodedString = (formEntries) => Object.entries(formEntries)
|
|
5476
5484
|
.map(([key, value]) => (0, smithy_client_1.extendedEncodeURIComponent)(key) + "=" + (0, smithy_client_1.extendedEncodeURIComponent)(value))
|
|
5477
5485
|
.join("&");
|