@aws-sdk/client-elastic-load-balancing-v2 3.131.0 → 3.142.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 +33 -0
- package/README.md +1 -1
- package/dist-cjs/commands/AddListenerCertificatesCommand.js +2 -2
- package/dist-cjs/commands/AddTagsCommand.js +2 -2
- package/dist-cjs/commands/CreateListenerCommand.js +2 -2
- package/dist-cjs/commands/CreateLoadBalancerCommand.js +2 -2
- package/dist-cjs/commands/CreateRuleCommand.js +2 -2
- package/dist-cjs/commands/CreateTargetGroupCommand.js +2 -2
- package/dist-cjs/commands/DeleteListenerCommand.js +2 -2
- package/dist-cjs/commands/DeleteLoadBalancerCommand.js +2 -2
- package/dist-cjs/commands/DeleteRuleCommand.js +2 -2
- package/dist-cjs/commands/DeleteTargetGroupCommand.js +2 -2
- package/dist-cjs/commands/DeregisterTargetsCommand.js +2 -2
- package/dist-cjs/commands/DescribeAccountLimitsCommand.js +2 -2
- package/dist-cjs/commands/DescribeListenerCertificatesCommand.js +2 -2
- package/dist-cjs/commands/DescribeListenersCommand.js +2 -2
- package/dist-cjs/commands/DescribeLoadBalancerAttributesCommand.js +2 -2
- package/dist-cjs/commands/DescribeLoadBalancersCommand.js +2 -2
- package/dist-cjs/commands/DescribeRulesCommand.js +2 -2
- package/dist-cjs/commands/DescribeSSLPoliciesCommand.js +2 -2
- package/dist-cjs/commands/DescribeTagsCommand.js +2 -2
- package/dist-cjs/commands/DescribeTargetGroupAttributesCommand.js +2 -2
- package/dist-cjs/commands/DescribeTargetGroupsCommand.js +2 -2
- package/dist-cjs/commands/DescribeTargetHealthCommand.js +2 -2
- package/dist-cjs/commands/ModifyListenerCommand.js +2 -2
- package/dist-cjs/commands/ModifyLoadBalancerAttributesCommand.js +2 -2
- package/dist-cjs/commands/ModifyRuleCommand.js +2 -2
- package/dist-cjs/commands/ModifyTargetGroupAttributesCommand.js +2 -2
- package/dist-cjs/commands/ModifyTargetGroupCommand.js +2 -2
- package/dist-cjs/commands/RegisterTargetsCommand.js +2 -2
- package/dist-cjs/commands/RemoveListenerCertificatesCommand.js +2 -2
- package/dist-cjs/commands/RemoveTagsCommand.js +2 -2
- package/dist-cjs/commands/SetIpAddressTypeCommand.js +2 -2
- package/dist-cjs/commands/SetRulePrioritiesCommand.js +2 -2
- package/dist-cjs/commands/SetSecurityGroupsCommand.js +2 -2
- package/dist-cjs/commands/SetSubnetsCommand.js +2 -2
- package/dist-cjs/models/models_0.js +424 -634
- package/dist-cjs/protocols/Aws_query.js +370 -547
- package/dist-es/commands/AddListenerCertificatesCommand.js +3 -3
- package/dist-es/commands/AddTagsCommand.js +3 -3
- package/dist-es/commands/CreateListenerCommand.js +3 -3
- package/dist-es/commands/CreateLoadBalancerCommand.js +3 -3
- package/dist-es/commands/CreateRuleCommand.js +3 -3
- package/dist-es/commands/CreateTargetGroupCommand.js +3 -3
- package/dist-es/commands/DeleteListenerCommand.js +3 -3
- package/dist-es/commands/DeleteLoadBalancerCommand.js +3 -3
- package/dist-es/commands/DeleteRuleCommand.js +3 -3
- package/dist-es/commands/DeleteTargetGroupCommand.js +3 -3
- package/dist-es/commands/DeregisterTargetsCommand.js +3 -3
- package/dist-es/commands/DescribeAccountLimitsCommand.js +3 -3
- package/dist-es/commands/DescribeListenerCertificatesCommand.js +3 -3
- package/dist-es/commands/DescribeListenersCommand.js +3 -3
- package/dist-es/commands/DescribeLoadBalancerAttributesCommand.js +3 -3
- package/dist-es/commands/DescribeLoadBalancersCommand.js +3 -3
- package/dist-es/commands/DescribeRulesCommand.js +3 -3
- package/dist-es/commands/DescribeSSLPoliciesCommand.js +3 -3
- package/dist-es/commands/DescribeTagsCommand.js +3 -3
- package/dist-es/commands/DescribeTargetGroupAttributesCommand.js +3 -3
- package/dist-es/commands/DescribeTargetGroupsCommand.js +3 -3
- package/dist-es/commands/DescribeTargetHealthCommand.js +3 -3
- package/dist-es/commands/ModifyListenerCommand.js +3 -3
- package/dist-es/commands/ModifyLoadBalancerAttributesCommand.js +3 -3
- package/dist-es/commands/ModifyRuleCommand.js +3 -3
- package/dist-es/commands/ModifyTargetGroupAttributesCommand.js +3 -3
- package/dist-es/commands/ModifyTargetGroupCommand.js +3 -3
- package/dist-es/commands/RegisterTargetsCommand.js +3 -3
- package/dist-es/commands/RemoveListenerCertificatesCommand.js +3 -3
- package/dist-es/commands/RemoveTagsCommand.js +3 -3
- package/dist-es/commands/SetIpAddressTypeCommand.js +3 -3
- package/dist-es/commands/SetRulePrioritiesCommand.js +3 -3
- package/dist-es/commands/SetSecurityGroupsCommand.js +3 -3
- package/dist-es/commands/SetSubnetsCommand.js +3 -3
- package/dist-es/models/models_0.js +105 -420
- package/dist-es/protocols/Aws_query.js +471 -548
- package/dist-types/models/models_0.d.ts +420 -630
- package/dist-types/ts3.4/models/models_0.d.ts +0 -128
- package/package.json +6 -6
|
@@ -469,7 +469,6 @@ const deserializeAws_queryAddListenerCertificatesCommandError = async (output, c
|
|
|
469
469
|
...output,
|
|
470
470
|
body: await parseBody(output.body, context),
|
|
471
471
|
};
|
|
472
|
-
let response;
|
|
473
472
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
474
473
|
switch (errorCode) {
|
|
475
474
|
case "CertificateNotFoundException":
|
|
@@ -483,14 +482,12 @@ const deserializeAws_queryAddListenerCertificatesCommandError = async (output, c
|
|
|
483
482
|
throw await deserializeAws_queryTooManyCertificatesExceptionResponse(parsedOutput, context);
|
|
484
483
|
default:
|
|
485
484
|
const parsedBody = parsedOutput.body;
|
|
486
|
-
|
|
487
|
-
|
|
488
|
-
|
|
489
|
-
|
|
490
|
-
|
|
491
|
-
$metadata,
|
|
485
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
486
|
+
output,
|
|
487
|
+
parsedBody: parsedBody.Error,
|
|
488
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
489
|
+
errorCode,
|
|
492
490
|
});
|
|
493
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
494
491
|
}
|
|
495
492
|
};
|
|
496
493
|
const deserializeAws_queryAddTagsCommand = async (output, context) => {
|
|
@@ -512,7 +509,6 @@ const deserializeAws_queryAddTagsCommandError = async (output, context) => {
|
|
|
512
509
|
...output,
|
|
513
510
|
body: await parseBody(output.body, context),
|
|
514
511
|
};
|
|
515
|
-
let response;
|
|
516
512
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
517
513
|
switch (errorCode) {
|
|
518
514
|
case "DuplicateTagKeysException":
|
|
@@ -535,14 +531,12 @@ const deserializeAws_queryAddTagsCommandError = async (output, context) => {
|
|
|
535
531
|
throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
|
|
536
532
|
default:
|
|
537
533
|
const parsedBody = parsedOutput.body;
|
|
538
|
-
|
|
539
|
-
|
|
540
|
-
|
|
541
|
-
|
|
542
|
-
|
|
543
|
-
$metadata,
|
|
534
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
535
|
+
output,
|
|
536
|
+
parsedBody: parsedBody.Error,
|
|
537
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
538
|
+
errorCode,
|
|
544
539
|
});
|
|
545
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
546
540
|
}
|
|
547
541
|
};
|
|
548
542
|
const deserializeAws_queryCreateListenerCommand = async (output, context) => {
|
|
@@ -564,7 +558,6 @@ const deserializeAws_queryCreateListenerCommandError = async (output, context) =
|
|
|
564
558
|
...output,
|
|
565
559
|
body: await parseBody(output.body, context),
|
|
566
560
|
};
|
|
567
|
-
let response;
|
|
568
561
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
569
562
|
switch (errorCode) {
|
|
570
563
|
case "ALPNPolicyNotSupportedException":
|
|
@@ -623,14 +616,12 @@ const deserializeAws_queryCreateListenerCommandError = async (output, context) =
|
|
|
623
616
|
throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
|
|
624
617
|
default:
|
|
625
618
|
const parsedBody = parsedOutput.body;
|
|
626
|
-
|
|
627
|
-
|
|
628
|
-
|
|
629
|
-
|
|
630
|
-
|
|
631
|
-
$metadata,
|
|
619
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
620
|
+
output,
|
|
621
|
+
parsedBody: parsedBody.Error,
|
|
622
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
623
|
+
errorCode,
|
|
632
624
|
});
|
|
633
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
634
625
|
}
|
|
635
626
|
};
|
|
636
627
|
const deserializeAws_queryCreateLoadBalancerCommand = async (output, context) => {
|
|
@@ -652,7 +643,6 @@ const deserializeAws_queryCreateLoadBalancerCommandError = async (output, contex
|
|
|
652
643
|
...output,
|
|
653
644
|
body: await parseBody(output.body, context),
|
|
654
645
|
};
|
|
655
|
-
let response;
|
|
656
646
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
657
647
|
switch (errorCode) {
|
|
658
648
|
case "AllocationIdNotFoundException":
|
|
@@ -696,14 +686,12 @@ const deserializeAws_queryCreateLoadBalancerCommandError = async (output, contex
|
|
|
696
686
|
throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
|
|
697
687
|
default:
|
|
698
688
|
const parsedBody = parsedOutput.body;
|
|
699
|
-
|
|
700
|
-
|
|
701
|
-
|
|
702
|
-
|
|
703
|
-
|
|
704
|
-
$metadata,
|
|
689
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
690
|
+
output,
|
|
691
|
+
parsedBody: parsedBody.Error,
|
|
692
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
693
|
+
errorCode,
|
|
705
694
|
});
|
|
706
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
707
695
|
}
|
|
708
696
|
};
|
|
709
697
|
const deserializeAws_queryCreateRuleCommand = async (output, context) => {
|
|
@@ -725,7 +713,6 @@ const deserializeAws_queryCreateRuleCommandError = async (output, context) => {
|
|
|
725
713
|
...output,
|
|
726
714
|
body: await parseBody(output.body, context),
|
|
727
715
|
};
|
|
728
|
-
let response;
|
|
729
716
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
730
717
|
switch (errorCode) {
|
|
731
718
|
case "IncompatibleProtocolsException":
|
|
@@ -775,14 +762,12 @@ const deserializeAws_queryCreateRuleCommandError = async (output, context) => {
|
|
|
775
762
|
throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
|
|
776
763
|
default:
|
|
777
764
|
const parsedBody = parsedOutput.body;
|
|
778
|
-
|
|
779
|
-
|
|
780
|
-
|
|
781
|
-
|
|
782
|
-
|
|
783
|
-
$metadata,
|
|
765
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
766
|
+
output,
|
|
767
|
+
parsedBody: parsedBody.Error,
|
|
768
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
769
|
+
errorCode,
|
|
784
770
|
});
|
|
785
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
786
771
|
}
|
|
787
772
|
};
|
|
788
773
|
const deserializeAws_queryCreateTargetGroupCommand = async (output, context) => {
|
|
@@ -804,7 +789,6 @@ const deserializeAws_queryCreateTargetGroupCommandError = async (output, context
|
|
|
804
789
|
...output,
|
|
805
790
|
body: await parseBody(output.body, context),
|
|
806
791
|
};
|
|
807
|
-
let response;
|
|
808
792
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
809
793
|
switch (errorCode) {
|
|
810
794
|
case "DuplicateTargetGroupNameException":
|
|
@@ -821,14 +805,12 @@ const deserializeAws_queryCreateTargetGroupCommandError = async (output, context
|
|
|
821
805
|
throw await deserializeAws_queryTooManyTargetGroupsExceptionResponse(parsedOutput, context);
|
|
822
806
|
default:
|
|
823
807
|
const parsedBody = parsedOutput.body;
|
|
824
|
-
|
|
825
|
-
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
$metadata,
|
|
808
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
809
|
+
output,
|
|
810
|
+
parsedBody: parsedBody.Error,
|
|
811
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
812
|
+
errorCode,
|
|
830
813
|
});
|
|
831
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
832
814
|
}
|
|
833
815
|
};
|
|
834
816
|
const deserializeAws_queryDeleteListenerCommand = async (output, context) => {
|
|
@@ -850,7 +832,6 @@ const deserializeAws_queryDeleteListenerCommandError = async (output, context) =
|
|
|
850
832
|
...output,
|
|
851
833
|
body: await parseBody(output.body, context),
|
|
852
834
|
};
|
|
853
|
-
let response;
|
|
854
835
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
855
836
|
switch (errorCode) {
|
|
856
837
|
case "ListenerNotFoundException":
|
|
@@ -861,14 +842,12 @@ const deserializeAws_queryDeleteListenerCommandError = async (output, context) =
|
|
|
861
842
|
throw await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context);
|
|
862
843
|
default:
|
|
863
844
|
const parsedBody = parsedOutput.body;
|
|
864
|
-
|
|
865
|
-
|
|
866
|
-
|
|
867
|
-
|
|
868
|
-
|
|
869
|
-
$metadata,
|
|
845
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
846
|
+
output,
|
|
847
|
+
parsedBody: parsedBody.Error,
|
|
848
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
849
|
+
errorCode,
|
|
870
850
|
});
|
|
871
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
872
851
|
}
|
|
873
852
|
};
|
|
874
853
|
const deserializeAws_queryDeleteLoadBalancerCommand = async (output, context) => {
|
|
@@ -890,7 +869,6 @@ const deserializeAws_queryDeleteLoadBalancerCommandError = async (output, contex
|
|
|
890
869
|
...output,
|
|
891
870
|
body: await parseBody(output.body, context),
|
|
892
871
|
};
|
|
893
|
-
let response;
|
|
894
872
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
895
873
|
switch (errorCode) {
|
|
896
874
|
case "LoadBalancerNotFoundException":
|
|
@@ -904,14 +882,12 @@ const deserializeAws_queryDeleteLoadBalancerCommandError = async (output, contex
|
|
|
904
882
|
throw await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context);
|
|
905
883
|
default:
|
|
906
884
|
const parsedBody = parsedOutput.body;
|
|
907
|
-
|
|
908
|
-
|
|
909
|
-
|
|
910
|
-
|
|
911
|
-
|
|
912
|
-
$metadata,
|
|
885
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
886
|
+
output,
|
|
887
|
+
parsedBody: parsedBody.Error,
|
|
888
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
889
|
+
errorCode,
|
|
913
890
|
});
|
|
914
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
915
891
|
}
|
|
916
892
|
};
|
|
917
893
|
const deserializeAws_queryDeleteRuleCommand = async (output, context) => {
|
|
@@ -933,7 +909,6 @@ const deserializeAws_queryDeleteRuleCommandError = async (output, context) => {
|
|
|
933
909
|
...output,
|
|
934
910
|
body: await parseBody(output.body, context),
|
|
935
911
|
};
|
|
936
|
-
let response;
|
|
937
912
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
938
913
|
switch (errorCode) {
|
|
939
914
|
case "OperationNotPermittedException":
|
|
@@ -944,14 +919,12 @@ const deserializeAws_queryDeleteRuleCommandError = async (output, context) => {
|
|
|
944
919
|
throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
|
|
945
920
|
default:
|
|
946
921
|
const parsedBody = parsedOutput.body;
|
|
947
|
-
|
|
948
|
-
|
|
949
|
-
|
|
950
|
-
|
|
951
|
-
|
|
952
|
-
$metadata,
|
|
922
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
923
|
+
output,
|
|
924
|
+
parsedBody: parsedBody.Error,
|
|
925
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
926
|
+
errorCode,
|
|
953
927
|
});
|
|
954
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
955
928
|
}
|
|
956
929
|
};
|
|
957
930
|
const deserializeAws_queryDeleteTargetGroupCommand = async (output, context) => {
|
|
@@ -973,7 +946,6 @@ const deserializeAws_queryDeleteTargetGroupCommandError = async (output, context
|
|
|
973
946
|
...output,
|
|
974
947
|
body: await parseBody(output.body, context),
|
|
975
948
|
};
|
|
976
|
-
let response;
|
|
977
949
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
978
950
|
switch (errorCode) {
|
|
979
951
|
case "ResourceInUseException":
|
|
@@ -981,14 +953,12 @@ const deserializeAws_queryDeleteTargetGroupCommandError = async (output, context
|
|
|
981
953
|
throw await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context);
|
|
982
954
|
default:
|
|
983
955
|
const parsedBody = parsedOutput.body;
|
|
984
|
-
|
|
985
|
-
|
|
986
|
-
|
|
987
|
-
|
|
988
|
-
|
|
989
|
-
$metadata,
|
|
956
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
957
|
+
output,
|
|
958
|
+
parsedBody: parsedBody.Error,
|
|
959
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
960
|
+
errorCode,
|
|
990
961
|
});
|
|
991
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
992
962
|
}
|
|
993
963
|
};
|
|
994
964
|
const deserializeAws_queryDeregisterTargetsCommand = async (output, context) => {
|
|
@@ -1010,7 +980,6 @@ const deserializeAws_queryDeregisterTargetsCommandError = async (output, context
|
|
|
1010
980
|
...output,
|
|
1011
981
|
body: await parseBody(output.body, context),
|
|
1012
982
|
};
|
|
1013
|
-
let response;
|
|
1014
983
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1015
984
|
switch (errorCode) {
|
|
1016
985
|
case "InvalidTargetException":
|
|
@@ -1021,14 +990,12 @@ const deserializeAws_queryDeregisterTargetsCommandError = async (output, context
|
|
|
1021
990
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
1022
991
|
default:
|
|
1023
992
|
const parsedBody = parsedOutput.body;
|
|
1024
|
-
|
|
1025
|
-
|
|
1026
|
-
|
|
1027
|
-
|
|
1028
|
-
|
|
1029
|
-
$metadata,
|
|
993
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
994
|
+
output,
|
|
995
|
+
parsedBody: parsedBody.Error,
|
|
996
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
997
|
+
errorCode,
|
|
1030
998
|
});
|
|
1031
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1032
999
|
}
|
|
1033
1000
|
};
|
|
1034
1001
|
const deserializeAws_queryDescribeAccountLimitsCommand = async (output, context) => {
|
|
@@ -1050,20 +1017,14 @@ const deserializeAws_queryDescribeAccountLimitsCommandError = async (output, con
|
|
|
1050
1017
|
...output,
|
|
1051
1018
|
body: await parseBody(output.body, context),
|
|
1052
1019
|
};
|
|
1053
|
-
let response;
|
|
1054
1020
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1055
|
-
|
|
1056
|
-
|
|
1057
|
-
|
|
1058
|
-
|
|
1059
|
-
|
|
1060
|
-
|
|
1061
|
-
|
|
1062
|
-
$fault: "client",
|
|
1063
|
-
$metadata,
|
|
1064
|
-
});
|
|
1065
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1066
|
-
}
|
|
1021
|
+
const parsedBody = parsedOutput.body;
|
|
1022
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1023
|
+
output,
|
|
1024
|
+
parsedBody: parsedBody.Error,
|
|
1025
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1026
|
+
errorCode,
|
|
1027
|
+
});
|
|
1067
1028
|
};
|
|
1068
1029
|
const deserializeAws_queryDescribeListenerCertificatesCommand = async (output, context) => {
|
|
1069
1030
|
if (output.statusCode >= 300) {
|
|
@@ -1084,7 +1045,6 @@ const deserializeAws_queryDescribeListenerCertificatesCommandError = async (outp
|
|
|
1084
1045
|
...output,
|
|
1085
1046
|
body: await parseBody(output.body, context),
|
|
1086
1047
|
};
|
|
1087
|
-
let response;
|
|
1088
1048
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1089
1049
|
switch (errorCode) {
|
|
1090
1050
|
case "ListenerNotFoundException":
|
|
@@ -1092,14 +1052,12 @@ const deserializeAws_queryDescribeListenerCertificatesCommandError = async (outp
|
|
|
1092
1052
|
throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
|
|
1093
1053
|
default:
|
|
1094
1054
|
const parsedBody = parsedOutput.body;
|
|
1095
|
-
|
|
1096
|
-
|
|
1097
|
-
|
|
1098
|
-
|
|
1099
|
-
|
|
1100
|
-
$metadata,
|
|
1055
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1056
|
+
output,
|
|
1057
|
+
parsedBody: parsedBody.Error,
|
|
1058
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1059
|
+
errorCode,
|
|
1101
1060
|
});
|
|
1102
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1103
1061
|
}
|
|
1104
1062
|
};
|
|
1105
1063
|
const deserializeAws_queryDescribeListenersCommand = async (output, context) => {
|
|
@@ -1121,7 +1079,6 @@ const deserializeAws_queryDescribeListenersCommandError = async (output, context
|
|
|
1121
1079
|
...output,
|
|
1122
1080
|
body: await parseBody(output.body, context),
|
|
1123
1081
|
};
|
|
1124
|
-
let response;
|
|
1125
1082
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1126
1083
|
switch (errorCode) {
|
|
1127
1084
|
case "ListenerNotFoundException":
|
|
@@ -1135,14 +1092,12 @@ const deserializeAws_queryDescribeListenersCommandError = async (output, context
|
|
|
1135
1092
|
throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
|
|
1136
1093
|
default:
|
|
1137
1094
|
const parsedBody = parsedOutput.body;
|
|
1138
|
-
|
|
1139
|
-
|
|
1140
|
-
|
|
1141
|
-
|
|
1142
|
-
|
|
1143
|
-
$metadata,
|
|
1095
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1096
|
+
output,
|
|
1097
|
+
parsedBody: parsedBody.Error,
|
|
1098
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1099
|
+
errorCode,
|
|
1144
1100
|
});
|
|
1145
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1146
1101
|
}
|
|
1147
1102
|
};
|
|
1148
1103
|
const deserializeAws_queryDescribeLoadBalancerAttributesCommand = async (output, context) => {
|
|
@@ -1164,7 +1119,6 @@ const deserializeAws_queryDescribeLoadBalancerAttributesCommandError = async (ou
|
|
|
1164
1119
|
...output,
|
|
1165
1120
|
body: await parseBody(output.body, context),
|
|
1166
1121
|
};
|
|
1167
|
-
let response;
|
|
1168
1122
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1169
1123
|
switch (errorCode) {
|
|
1170
1124
|
case "LoadBalancerNotFoundException":
|
|
@@ -1172,14 +1126,12 @@ const deserializeAws_queryDescribeLoadBalancerAttributesCommandError = async (ou
|
|
|
1172
1126
|
throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
|
|
1173
1127
|
default:
|
|
1174
1128
|
const parsedBody = parsedOutput.body;
|
|
1175
|
-
|
|
1176
|
-
|
|
1177
|
-
|
|
1178
|
-
|
|
1179
|
-
|
|
1180
|
-
$metadata,
|
|
1129
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1130
|
+
output,
|
|
1131
|
+
parsedBody: parsedBody.Error,
|
|
1132
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1133
|
+
errorCode,
|
|
1181
1134
|
});
|
|
1182
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1183
1135
|
}
|
|
1184
1136
|
};
|
|
1185
1137
|
const deserializeAws_queryDescribeLoadBalancersCommand = async (output, context) => {
|
|
@@ -1201,7 +1153,6 @@ const deserializeAws_queryDescribeLoadBalancersCommandError = async (output, con
|
|
|
1201
1153
|
...output,
|
|
1202
1154
|
body: await parseBody(output.body, context),
|
|
1203
1155
|
};
|
|
1204
|
-
let response;
|
|
1205
1156
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1206
1157
|
switch (errorCode) {
|
|
1207
1158
|
case "LoadBalancerNotFoundException":
|
|
@@ -1209,14 +1160,12 @@ const deserializeAws_queryDescribeLoadBalancersCommandError = async (output, con
|
|
|
1209
1160
|
throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
|
|
1210
1161
|
default:
|
|
1211
1162
|
const parsedBody = parsedOutput.body;
|
|
1212
|
-
|
|
1213
|
-
|
|
1214
|
-
|
|
1215
|
-
|
|
1216
|
-
|
|
1217
|
-
$metadata,
|
|
1163
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1164
|
+
output,
|
|
1165
|
+
parsedBody: parsedBody.Error,
|
|
1166
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1167
|
+
errorCode,
|
|
1218
1168
|
});
|
|
1219
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1220
1169
|
}
|
|
1221
1170
|
};
|
|
1222
1171
|
const deserializeAws_queryDescribeRulesCommand = async (output, context) => {
|
|
@@ -1238,7 +1187,6 @@ const deserializeAws_queryDescribeRulesCommandError = async (output, context) =>
|
|
|
1238
1187
|
...output,
|
|
1239
1188
|
body: await parseBody(output.body, context),
|
|
1240
1189
|
};
|
|
1241
|
-
let response;
|
|
1242
1190
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1243
1191
|
switch (errorCode) {
|
|
1244
1192
|
case "ListenerNotFoundException":
|
|
@@ -1252,14 +1200,12 @@ const deserializeAws_queryDescribeRulesCommandError = async (output, context) =>
|
|
|
1252
1200
|
throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
|
|
1253
1201
|
default:
|
|
1254
1202
|
const parsedBody = parsedOutput.body;
|
|
1255
|
-
|
|
1256
|
-
|
|
1257
|
-
|
|
1258
|
-
|
|
1259
|
-
|
|
1260
|
-
$metadata,
|
|
1203
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1204
|
+
output,
|
|
1205
|
+
parsedBody: parsedBody.Error,
|
|
1206
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1207
|
+
errorCode,
|
|
1261
1208
|
});
|
|
1262
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1263
1209
|
}
|
|
1264
1210
|
};
|
|
1265
1211
|
const deserializeAws_queryDescribeSSLPoliciesCommand = async (output, context) => {
|
|
@@ -1281,7 +1227,6 @@ const deserializeAws_queryDescribeSSLPoliciesCommandError = async (output, conte
|
|
|
1281
1227
|
...output,
|
|
1282
1228
|
body: await parseBody(output.body, context),
|
|
1283
1229
|
};
|
|
1284
|
-
let response;
|
|
1285
1230
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1286
1231
|
switch (errorCode) {
|
|
1287
1232
|
case "SSLPolicyNotFoundException":
|
|
@@ -1289,14 +1234,12 @@ const deserializeAws_queryDescribeSSLPoliciesCommandError = async (output, conte
|
|
|
1289
1234
|
throw await deserializeAws_querySSLPolicyNotFoundExceptionResponse(parsedOutput, context);
|
|
1290
1235
|
default:
|
|
1291
1236
|
const parsedBody = parsedOutput.body;
|
|
1292
|
-
|
|
1293
|
-
|
|
1294
|
-
|
|
1295
|
-
|
|
1296
|
-
|
|
1297
|
-
$metadata,
|
|
1237
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1238
|
+
output,
|
|
1239
|
+
parsedBody: parsedBody.Error,
|
|
1240
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1241
|
+
errorCode,
|
|
1298
1242
|
});
|
|
1299
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1300
1243
|
}
|
|
1301
1244
|
};
|
|
1302
1245
|
const deserializeAws_queryDescribeTagsCommand = async (output, context) => {
|
|
@@ -1318,7 +1261,6 @@ const deserializeAws_queryDescribeTagsCommandError = async (output, context) =>
|
|
|
1318
1261
|
...output,
|
|
1319
1262
|
body: await parseBody(output.body, context),
|
|
1320
1263
|
};
|
|
1321
|
-
let response;
|
|
1322
1264
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1323
1265
|
switch (errorCode) {
|
|
1324
1266
|
case "ListenerNotFoundException":
|
|
@@ -1335,14 +1277,12 @@ const deserializeAws_queryDescribeTagsCommandError = async (output, context) =>
|
|
|
1335
1277
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
1336
1278
|
default:
|
|
1337
1279
|
const parsedBody = parsedOutput.body;
|
|
1338
|
-
|
|
1339
|
-
|
|
1340
|
-
|
|
1341
|
-
|
|
1342
|
-
|
|
1343
|
-
$metadata,
|
|
1280
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1281
|
+
output,
|
|
1282
|
+
parsedBody: parsedBody.Error,
|
|
1283
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1284
|
+
errorCode,
|
|
1344
1285
|
});
|
|
1345
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1346
1286
|
}
|
|
1347
1287
|
};
|
|
1348
1288
|
const deserializeAws_queryDescribeTargetGroupAttributesCommand = async (output, context) => {
|
|
@@ -1364,7 +1304,6 @@ const deserializeAws_queryDescribeTargetGroupAttributesCommandError = async (out
|
|
|
1364
1304
|
...output,
|
|
1365
1305
|
body: await parseBody(output.body, context),
|
|
1366
1306
|
};
|
|
1367
|
-
let response;
|
|
1368
1307
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1369
1308
|
switch (errorCode) {
|
|
1370
1309
|
case "TargetGroupNotFoundException":
|
|
@@ -1372,14 +1311,12 @@ const deserializeAws_queryDescribeTargetGroupAttributesCommandError = async (out
|
|
|
1372
1311
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
1373
1312
|
default:
|
|
1374
1313
|
const parsedBody = parsedOutput.body;
|
|
1375
|
-
|
|
1376
|
-
|
|
1377
|
-
|
|
1378
|
-
|
|
1379
|
-
|
|
1380
|
-
$metadata,
|
|
1314
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1315
|
+
output,
|
|
1316
|
+
parsedBody: parsedBody.Error,
|
|
1317
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1318
|
+
errorCode,
|
|
1381
1319
|
});
|
|
1382
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1383
1320
|
}
|
|
1384
1321
|
};
|
|
1385
1322
|
const deserializeAws_queryDescribeTargetGroupsCommand = async (output, context) => {
|
|
@@ -1401,7 +1338,6 @@ const deserializeAws_queryDescribeTargetGroupsCommandError = async (output, cont
|
|
|
1401
1338
|
...output,
|
|
1402
1339
|
body: await parseBody(output.body, context),
|
|
1403
1340
|
};
|
|
1404
|
-
let response;
|
|
1405
1341
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1406
1342
|
switch (errorCode) {
|
|
1407
1343
|
case "LoadBalancerNotFoundException":
|
|
@@ -1412,14 +1348,12 @@ const deserializeAws_queryDescribeTargetGroupsCommandError = async (output, cont
|
|
|
1412
1348
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
1413
1349
|
default:
|
|
1414
1350
|
const parsedBody = parsedOutput.body;
|
|
1415
|
-
|
|
1416
|
-
|
|
1417
|
-
|
|
1418
|
-
|
|
1419
|
-
|
|
1420
|
-
$metadata,
|
|
1351
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1352
|
+
output,
|
|
1353
|
+
parsedBody: parsedBody.Error,
|
|
1354
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1355
|
+
errorCode,
|
|
1421
1356
|
});
|
|
1422
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1423
1357
|
}
|
|
1424
1358
|
};
|
|
1425
1359
|
const deserializeAws_queryDescribeTargetHealthCommand = async (output, context) => {
|
|
@@ -1441,7 +1375,6 @@ const deserializeAws_queryDescribeTargetHealthCommandError = async (output, cont
|
|
|
1441
1375
|
...output,
|
|
1442
1376
|
body: await parseBody(output.body, context),
|
|
1443
1377
|
};
|
|
1444
|
-
let response;
|
|
1445
1378
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1446
1379
|
switch (errorCode) {
|
|
1447
1380
|
case "HealthUnavailableException":
|
|
@@ -1455,14 +1388,12 @@ const deserializeAws_queryDescribeTargetHealthCommandError = async (output, cont
|
|
|
1455
1388
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
1456
1389
|
default:
|
|
1457
1390
|
const parsedBody = parsedOutput.body;
|
|
1458
|
-
|
|
1459
|
-
|
|
1460
|
-
|
|
1461
|
-
|
|
1462
|
-
|
|
1463
|
-
$metadata,
|
|
1391
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1392
|
+
output,
|
|
1393
|
+
parsedBody: parsedBody.Error,
|
|
1394
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1395
|
+
errorCode,
|
|
1464
1396
|
});
|
|
1465
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1466
1397
|
}
|
|
1467
1398
|
};
|
|
1468
1399
|
const deserializeAws_queryModifyListenerCommand = async (output, context) => {
|
|
@@ -1484,7 +1415,6 @@ const deserializeAws_queryModifyListenerCommandError = async (output, context) =
|
|
|
1484
1415
|
...output,
|
|
1485
1416
|
body: await parseBody(output.body, context),
|
|
1486
1417
|
};
|
|
1487
|
-
let response;
|
|
1488
1418
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1489
1419
|
switch (errorCode) {
|
|
1490
1420
|
case "ALPNPolicyNotSupportedException":
|
|
@@ -1540,14 +1470,12 @@ const deserializeAws_queryModifyListenerCommandError = async (output, context) =
|
|
|
1540
1470
|
throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
|
|
1541
1471
|
default:
|
|
1542
1472
|
const parsedBody = parsedOutput.body;
|
|
1543
|
-
|
|
1544
|
-
|
|
1545
|
-
|
|
1546
|
-
|
|
1547
|
-
|
|
1548
|
-
$metadata,
|
|
1473
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1474
|
+
output,
|
|
1475
|
+
parsedBody: parsedBody.Error,
|
|
1476
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1477
|
+
errorCode,
|
|
1549
1478
|
});
|
|
1550
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1551
1479
|
}
|
|
1552
1480
|
};
|
|
1553
1481
|
const deserializeAws_queryModifyLoadBalancerAttributesCommand = async (output, context) => {
|
|
@@ -1569,7 +1497,6 @@ const deserializeAws_queryModifyLoadBalancerAttributesCommandError = async (outp
|
|
|
1569
1497
|
...output,
|
|
1570
1498
|
body: await parseBody(output.body, context),
|
|
1571
1499
|
};
|
|
1572
|
-
let response;
|
|
1573
1500
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1574
1501
|
switch (errorCode) {
|
|
1575
1502
|
case "InvalidConfigurationRequestException":
|
|
@@ -1580,14 +1507,12 @@ const deserializeAws_queryModifyLoadBalancerAttributesCommandError = async (outp
|
|
|
1580
1507
|
throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
|
|
1581
1508
|
default:
|
|
1582
1509
|
const parsedBody = parsedOutput.body;
|
|
1583
|
-
|
|
1584
|
-
|
|
1585
|
-
|
|
1586
|
-
|
|
1587
|
-
|
|
1588
|
-
$metadata,
|
|
1510
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1511
|
+
output,
|
|
1512
|
+
parsedBody: parsedBody.Error,
|
|
1513
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1514
|
+
errorCode,
|
|
1589
1515
|
});
|
|
1590
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1591
1516
|
}
|
|
1592
1517
|
};
|
|
1593
1518
|
const deserializeAws_queryModifyRuleCommand = async (output, context) => {
|
|
@@ -1609,7 +1534,6 @@ const deserializeAws_queryModifyRuleCommandError = async (output, context) => {
|
|
|
1609
1534
|
...output,
|
|
1610
1535
|
body: await parseBody(output.body, context),
|
|
1611
1536
|
};
|
|
1612
|
-
let response;
|
|
1613
1537
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1614
1538
|
switch (errorCode) {
|
|
1615
1539
|
case "IncompatibleProtocolsException":
|
|
@@ -1647,14 +1571,12 @@ const deserializeAws_queryModifyRuleCommandError = async (output, context) => {
|
|
|
1647
1571
|
throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
|
|
1648
1572
|
default:
|
|
1649
1573
|
const parsedBody = parsedOutput.body;
|
|
1650
|
-
|
|
1651
|
-
|
|
1652
|
-
|
|
1653
|
-
|
|
1654
|
-
|
|
1655
|
-
$metadata,
|
|
1574
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1575
|
+
output,
|
|
1576
|
+
parsedBody: parsedBody.Error,
|
|
1577
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1578
|
+
errorCode,
|
|
1656
1579
|
});
|
|
1657
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1658
1580
|
}
|
|
1659
1581
|
};
|
|
1660
1582
|
const deserializeAws_queryModifyTargetGroupCommand = async (output, context) => {
|
|
@@ -1676,7 +1598,6 @@ const deserializeAws_queryModifyTargetGroupCommandError = async (output, context
|
|
|
1676
1598
|
...output,
|
|
1677
1599
|
body: await parseBody(output.body, context),
|
|
1678
1600
|
};
|
|
1679
|
-
let response;
|
|
1680
1601
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1681
1602
|
switch (errorCode) {
|
|
1682
1603
|
case "InvalidConfigurationRequestException":
|
|
@@ -1687,14 +1608,12 @@ const deserializeAws_queryModifyTargetGroupCommandError = async (output, context
|
|
|
1687
1608
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
1688
1609
|
default:
|
|
1689
1610
|
const parsedBody = parsedOutput.body;
|
|
1690
|
-
|
|
1691
|
-
|
|
1692
|
-
|
|
1693
|
-
|
|
1694
|
-
|
|
1695
|
-
$metadata,
|
|
1611
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1612
|
+
output,
|
|
1613
|
+
parsedBody: parsedBody.Error,
|
|
1614
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1615
|
+
errorCode,
|
|
1696
1616
|
});
|
|
1697
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1698
1617
|
}
|
|
1699
1618
|
};
|
|
1700
1619
|
const deserializeAws_queryModifyTargetGroupAttributesCommand = async (output, context) => {
|
|
@@ -1716,7 +1635,6 @@ const deserializeAws_queryModifyTargetGroupAttributesCommandError = async (outpu
|
|
|
1716
1635
|
...output,
|
|
1717
1636
|
body: await parseBody(output.body, context),
|
|
1718
1637
|
};
|
|
1719
|
-
let response;
|
|
1720
1638
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1721
1639
|
switch (errorCode) {
|
|
1722
1640
|
case "InvalidConfigurationRequestException":
|
|
@@ -1727,14 +1645,12 @@ const deserializeAws_queryModifyTargetGroupAttributesCommandError = async (outpu
|
|
|
1727
1645
|
throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
|
|
1728
1646
|
default:
|
|
1729
1647
|
const parsedBody = parsedOutput.body;
|
|
1730
|
-
|
|
1731
|
-
|
|
1732
|
-
|
|
1733
|
-
|
|
1734
|
-
|
|
1735
|
-
$metadata,
|
|
1648
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1649
|
+
output,
|
|
1650
|
+
parsedBody: parsedBody.Error,
|
|
1651
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1652
|
+
errorCode,
|
|
1736
1653
|
});
|
|
1737
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1738
1654
|
}
|
|
1739
1655
|
};
|
|
1740
1656
|
const deserializeAws_queryRegisterTargetsCommand = async (output, context) => {
|
|
@@ -1756,7 +1672,6 @@ const deserializeAws_queryRegisterTargetsCommandError = async (output, context)
|
|
|
1756
1672
|
...output,
|
|
1757
1673
|
body: await parseBody(output.body, context),
|
|
1758
1674
|
};
|
|
1759
|
-
let response;
|
|
1760
1675
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1761
1676
|
switch (errorCode) {
|
|
1762
1677
|
case "InvalidTargetException":
|
|
@@ -1773,14 +1688,12 @@ const deserializeAws_queryRegisterTargetsCommandError = async (output, context)
|
|
|
1773
1688
|
throw await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context);
|
|
1774
1689
|
default:
|
|
1775
1690
|
const parsedBody = parsedOutput.body;
|
|
1776
|
-
|
|
1777
|
-
|
|
1778
|
-
|
|
1779
|
-
|
|
1780
|
-
|
|
1781
|
-
$metadata,
|
|
1691
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1692
|
+
output,
|
|
1693
|
+
parsedBody: parsedBody.Error,
|
|
1694
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1695
|
+
errorCode,
|
|
1782
1696
|
});
|
|
1783
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1784
1697
|
}
|
|
1785
1698
|
};
|
|
1786
1699
|
const deserializeAws_queryRemoveListenerCertificatesCommand = async (output, context) => {
|
|
@@ -1802,7 +1715,6 @@ const deserializeAws_queryRemoveListenerCertificatesCommandError = async (output
|
|
|
1802
1715
|
...output,
|
|
1803
1716
|
body: await parseBody(output.body, context),
|
|
1804
1717
|
};
|
|
1805
|
-
let response;
|
|
1806
1718
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1807
1719
|
switch (errorCode) {
|
|
1808
1720
|
case "ListenerNotFoundException":
|
|
@@ -1813,14 +1725,12 @@ const deserializeAws_queryRemoveListenerCertificatesCommandError = async (output
|
|
|
1813
1725
|
throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
|
|
1814
1726
|
default:
|
|
1815
1727
|
const parsedBody = parsedOutput.body;
|
|
1816
|
-
|
|
1817
|
-
|
|
1818
|
-
|
|
1819
|
-
|
|
1820
|
-
|
|
1821
|
-
$metadata,
|
|
1728
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1729
|
+
output,
|
|
1730
|
+
parsedBody: parsedBody.Error,
|
|
1731
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1732
|
+
errorCode,
|
|
1822
1733
|
});
|
|
1823
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1824
1734
|
}
|
|
1825
1735
|
};
|
|
1826
1736
|
const deserializeAws_queryRemoveTagsCommand = async (output, context) => {
|
|
@@ -1842,7 +1752,6 @@ const deserializeAws_queryRemoveTagsCommandError = async (output, context) => {
|
|
|
1842
1752
|
...output,
|
|
1843
1753
|
body: await parseBody(output.body, context),
|
|
1844
1754
|
};
|
|
1845
|
-
let response;
|
|
1846
1755
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1847
1756
|
switch (errorCode) {
|
|
1848
1757
|
case "ListenerNotFoundException":
|
|
@@ -1862,14 +1771,12 @@ const deserializeAws_queryRemoveTagsCommandError = async (output, context) => {
|
|
|
1862
1771
|
throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
|
|
1863
1772
|
default:
|
|
1864
1773
|
const parsedBody = parsedOutput.body;
|
|
1865
|
-
|
|
1866
|
-
|
|
1867
|
-
|
|
1868
|
-
|
|
1869
|
-
|
|
1870
|
-
$metadata,
|
|
1774
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1775
|
+
output,
|
|
1776
|
+
parsedBody: parsedBody.Error,
|
|
1777
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1778
|
+
errorCode,
|
|
1871
1779
|
});
|
|
1872
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1873
1780
|
}
|
|
1874
1781
|
};
|
|
1875
1782
|
const deserializeAws_querySetIpAddressTypeCommand = async (output, context) => {
|
|
@@ -1891,7 +1798,6 @@ const deserializeAws_querySetIpAddressTypeCommandError = async (output, context)
|
|
|
1891
1798
|
...output,
|
|
1892
1799
|
body: await parseBody(output.body, context),
|
|
1893
1800
|
};
|
|
1894
|
-
let response;
|
|
1895
1801
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1896
1802
|
switch (errorCode) {
|
|
1897
1803
|
case "InvalidConfigurationRequestException":
|
|
@@ -1905,14 +1811,12 @@ const deserializeAws_querySetIpAddressTypeCommandError = async (output, context)
|
|
|
1905
1811
|
throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
|
|
1906
1812
|
default:
|
|
1907
1813
|
const parsedBody = parsedOutput.body;
|
|
1908
|
-
|
|
1909
|
-
|
|
1910
|
-
|
|
1911
|
-
|
|
1912
|
-
|
|
1913
|
-
$metadata,
|
|
1814
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1815
|
+
output,
|
|
1816
|
+
parsedBody: parsedBody.Error,
|
|
1817
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1818
|
+
errorCode,
|
|
1914
1819
|
});
|
|
1915
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1916
1820
|
}
|
|
1917
1821
|
};
|
|
1918
1822
|
const deserializeAws_querySetRulePrioritiesCommand = async (output, context) => {
|
|
@@ -1934,7 +1838,6 @@ const deserializeAws_querySetRulePrioritiesCommandError = async (output, context
|
|
|
1934
1838
|
...output,
|
|
1935
1839
|
body: await parseBody(output.body, context),
|
|
1936
1840
|
};
|
|
1937
|
-
let response;
|
|
1938
1841
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1939
1842
|
switch (errorCode) {
|
|
1940
1843
|
case "OperationNotPermittedException":
|
|
@@ -1948,14 +1851,12 @@ const deserializeAws_querySetRulePrioritiesCommandError = async (output, context
|
|
|
1948
1851
|
throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
|
|
1949
1852
|
default:
|
|
1950
1853
|
const parsedBody = parsedOutput.body;
|
|
1951
|
-
|
|
1952
|
-
|
|
1953
|
-
|
|
1954
|
-
|
|
1955
|
-
|
|
1956
|
-
$metadata,
|
|
1854
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1855
|
+
output,
|
|
1856
|
+
parsedBody: parsedBody.Error,
|
|
1857
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1858
|
+
errorCode,
|
|
1957
1859
|
});
|
|
1958
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
1959
1860
|
}
|
|
1960
1861
|
};
|
|
1961
1862
|
const deserializeAws_querySetSecurityGroupsCommand = async (output, context) => {
|
|
@@ -1977,7 +1878,6 @@ const deserializeAws_querySetSecurityGroupsCommandError = async (output, context
|
|
|
1977
1878
|
...output,
|
|
1978
1879
|
body: await parseBody(output.body, context),
|
|
1979
1880
|
};
|
|
1980
|
-
let response;
|
|
1981
1881
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1982
1882
|
switch (errorCode) {
|
|
1983
1883
|
case "InvalidConfigurationRequestException":
|
|
@@ -1991,14 +1891,12 @@ const deserializeAws_querySetSecurityGroupsCommandError = async (output, context
|
|
|
1991
1891
|
throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
|
|
1992
1892
|
default:
|
|
1993
1893
|
const parsedBody = parsedOutput.body;
|
|
1994
|
-
|
|
1995
|
-
|
|
1996
|
-
|
|
1997
|
-
|
|
1998
|
-
|
|
1999
|
-
$metadata,
|
|
1894
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1895
|
+
output,
|
|
1896
|
+
parsedBody: parsedBody.Error,
|
|
1897
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1898
|
+
errorCode,
|
|
2000
1899
|
});
|
|
2001
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
2002
1900
|
}
|
|
2003
1901
|
};
|
|
2004
1902
|
const deserializeAws_querySetSubnetsCommand = async (output, context) => {
|
|
@@ -2020,7 +1918,6 @@ const deserializeAws_querySetSubnetsCommandError = async (output, context) => {
|
|
|
2020
1918
|
...output,
|
|
2021
1919
|
body: await parseBody(output.body, context),
|
|
2022
1920
|
};
|
|
2023
|
-
let response;
|
|
2024
1921
|
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2025
1922
|
switch (errorCode) {
|
|
2026
1923
|
case "AllocationIdNotFoundException":
|
|
@@ -2043,14 +1940,12 @@ const deserializeAws_querySetSubnetsCommandError = async (output, context) => {
|
|
|
2043
1940
|
throw await deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context);
|
|
2044
1941
|
default:
|
|
2045
1942
|
const parsedBody = parsedOutput.body;
|
|
2046
|
-
|
|
2047
|
-
|
|
2048
|
-
|
|
2049
|
-
|
|
2050
|
-
|
|
2051
|
-
$metadata,
|
|
1943
|
+
(0, smithy_client_1.throwDefaultError)({
|
|
1944
|
+
output,
|
|
1945
|
+
parsedBody: parsedBody.Error,
|
|
1946
|
+
exceptionCtor: ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException,
|
|
1947
|
+
errorCode,
|
|
2052
1948
|
});
|
|
2053
|
-
throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
|
|
2054
1949
|
}
|
|
2055
1950
|
};
|
|
2056
1951
|
const deserializeAws_queryAllocationIdNotFoundExceptionResponse = async (parsedOutput, context) => {
|
|
@@ -2388,44 +2283,44 @@ const deserializeAws_queryUnsupportedProtocolExceptionResponse = async (parsedOu
|
|
|
2388
2283
|
};
|
|
2389
2284
|
const serializeAws_queryAction = (input, context) => {
|
|
2390
2285
|
const entries = {};
|
|
2391
|
-
if (input.Type
|
|
2286
|
+
if (input.Type != null) {
|
|
2392
2287
|
entries["Type"] = input.Type;
|
|
2393
2288
|
}
|
|
2394
|
-
if (input.TargetGroupArn
|
|
2289
|
+
if (input.TargetGroupArn != null) {
|
|
2395
2290
|
entries["TargetGroupArn"] = input.TargetGroupArn;
|
|
2396
2291
|
}
|
|
2397
|
-
if (input.AuthenticateOidcConfig
|
|
2292
|
+
if (input.AuthenticateOidcConfig != null) {
|
|
2398
2293
|
const memberEntries = serializeAws_queryAuthenticateOidcActionConfig(input.AuthenticateOidcConfig, context);
|
|
2399
2294
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2400
2295
|
const loc = `AuthenticateOidcConfig.${key}`;
|
|
2401
2296
|
entries[loc] = value;
|
|
2402
2297
|
});
|
|
2403
2298
|
}
|
|
2404
|
-
if (input.AuthenticateCognitoConfig
|
|
2299
|
+
if (input.AuthenticateCognitoConfig != null) {
|
|
2405
2300
|
const memberEntries = serializeAws_queryAuthenticateCognitoActionConfig(input.AuthenticateCognitoConfig, context);
|
|
2406
2301
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2407
2302
|
const loc = `AuthenticateCognitoConfig.${key}`;
|
|
2408
2303
|
entries[loc] = value;
|
|
2409
2304
|
});
|
|
2410
2305
|
}
|
|
2411
|
-
if (input.Order
|
|
2306
|
+
if (input.Order != null) {
|
|
2412
2307
|
entries["Order"] = input.Order;
|
|
2413
2308
|
}
|
|
2414
|
-
if (input.RedirectConfig
|
|
2309
|
+
if (input.RedirectConfig != null) {
|
|
2415
2310
|
const memberEntries = serializeAws_queryRedirectActionConfig(input.RedirectConfig, context);
|
|
2416
2311
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2417
2312
|
const loc = `RedirectConfig.${key}`;
|
|
2418
2313
|
entries[loc] = value;
|
|
2419
2314
|
});
|
|
2420
2315
|
}
|
|
2421
|
-
if (input.FixedResponseConfig
|
|
2316
|
+
if (input.FixedResponseConfig != null) {
|
|
2422
2317
|
const memberEntries = serializeAws_queryFixedResponseActionConfig(input.FixedResponseConfig, context);
|
|
2423
2318
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2424
2319
|
const loc = `FixedResponseConfig.${key}`;
|
|
2425
2320
|
entries[loc] = value;
|
|
2426
2321
|
});
|
|
2427
2322
|
}
|
|
2428
|
-
if (input.ForwardConfig
|
|
2323
|
+
if (input.ForwardConfig != null) {
|
|
2429
2324
|
const memberEntries = serializeAws_queryForwardActionConfig(input.ForwardConfig, context);
|
|
2430
2325
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2431
2326
|
const loc = `ForwardConfig.${key}`;
|
|
@@ -2451,10 +2346,10 @@ const serializeAws_queryActions = (input, context) => {
|
|
|
2451
2346
|
};
|
|
2452
2347
|
const serializeAws_queryAddListenerCertificatesInput = (input, context) => {
|
|
2453
2348
|
const entries = {};
|
|
2454
|
-
if (input.ListenerArn
|
|
2349
|
+
if (input.ListenerArn != null) {
|
|
2455
2350
|
entries["ListenerArn"] = input.ListenerArn;
|
|
2456
2351
|
}
|
|
2457
|
-
if (input.Certificates
|
|
2352
|
+
if (input.Certificates != null) {
|
|
2458
2353
|
const memberEntries = serializeAws_queryCertificateList(input.Certificates, context);
|
|
2459
2354
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2460
2355
|
const loc = `Certificates.${key}`;
|
|
@@ -2465,14 +2360,14 @@ const serializeAws_queryAddListenerCertificatesInput = (input, context) => {
|
|
|
2465
2360
|
};
|
|
2466
2361
|
const serializeAws_queryAddTagsInput = (input, context) => {
|
|
2467
2362
|
const entries = {};
|
|
2468
|
-
if (input.ResourceArns
|
|
2363
|
+
if (input.ResourceArns != null) {
|
|
2469
2364
|
const memberEntries = serializeAws_queryResourceArns(input.ResourceArns, context);
|
|
2470
2365
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2471
2366
|
const loc = `ResourceArns.${key}`;
|
|
2472
2367
|
entries[loc] = value;
|
|
2473
2368
|
});
|
|
2474
2369
|
}
|
|
2475
|
-
if (input.Tags
|
|
2370
|
+
if (input.Tags != null) {
|
|
2476
2371
|
const memberEntries = serializeAws_queryTagList(input.Tags, context);
|
|
2477
2372
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2478
2373
|
const loc = `Tags.${key}`;
|
|
@@ -2507,32 +2402,32 @@ const serializeAws_queryAuthenticateCognitoActionAuthenticationRequestExtraParam
|
|
|
2507
2402
|
};
|
|
2508
2403
|
const serializeAws_queryAuthenticateCognitoActionConfig = (input, context) => {
|
|
2509
2404
|
const entries = {};
|
|
2510
|
-
if (input.UserPoolArn
|
|
2405
|
+
if (input.UserPoolArn != null) {
|
|
2511
2406
|
entries["UserPoolArn"] = input.UserPoolArn;
|
|
2512
2407
|
}
|
|
2513
|
-
if (input.UserPoolClientId
|
|
2408
|
+
if (input.UserPoolClientId != null) {
|
|
2514
2409
|
entries["UserPoolClientId"] = input.UserPoolClientId;
|
|
2515
2410
|
}
|
|
2516
|
-
if (input.UserPoolDomain
|
|
2411
|
+
if (input.UserPoolDomain != null) {
|
|
2517
2412
|
entries["UserPoolDomain"] = input.UserPoolDomain;
|
|
2518
2413
|
}
|
|
2519
|
-
if (input.SessionCookieName
|
|
2414
|
+
if (input.SessionCookieName != null) {
|
|
2520
2415
|
entries["SessionCookieName"] = input.SessionCookieName;
|
|
2521
2416
|
}
|
|
2522
|
-
if (input.Scope
|
|
2417
|
+
if (input.Scope != null) {
|
|
2523
2418
|
entries["Scope"] = input.Scope;
|
|
2524
2419
|
}
|
|
2525
|
-
if (input.SessionTimeout
|
|
2420
|
+
if (input.SessionTimeout != null) {
|
|
2526
2421
|
entries["SessionTimeout"] = input.SessionTimeout;
|
|
2527
2422
|
}
|
|
2528
|
-
if (input.AuthenticationRequestExtraParams
|
|
2423
|
+
if (input.AuthenticationRequestExtraParams != null) {
|
|
2529
2424
|
const memberEntries = serializeAws_queryAuthenticateCognitoActionAuthenticationRequestExtraParams(input.AuthenticationRequestExtraParams, context);
|
|
2530
2425
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2531
2426
|
const loc = `AuthenticationRequestExtraParams.${key}`;
|
|
2532
2427
|
entries[loc] = value;
|
|
2533
2428
|
});
|
|
2534
2429
|
}
|
|
2535
|
-
if (input.OnUnauthenticatedRequest
|
|
2430
|
+
if (input.OnUnauthenticatedRequest != null) {
|
|
2536
2431
|
entries["OnUnauthenticatedRequest"] = input.OnUnauthenticatedRequest;
|
|
2537
2432
|
}
|
|
2538
2433
|
return entries;
|
|
@@ -2551,54 +2446,54 @@ const serializeAws_queryAuthenticateOidcActionAuthenticationRequestExtraParams =
|
|
|
2551
2446
|
};
|
|
2552
2447
|
const serializeAws_queryAuthenticateOidcActionConfig = (input, context) => {
|
|
2553
2448
|
const entries = {};
|
|
2554
|
-
if (input.Issuer
|
|
2449
|
+
if (input.Issuer != null) {
|
|
2555
2450
|
entries["Issuer"] = input.Issuer;
|
|
2556
2451
|
}
|
|
2557
|
-
if (input.AuthorizationEndpoint
|
|
2452
|
+
if (input.AuthorizationEndpoint != null) {
|
|
2558
2453
|
entries["AuthorizationEndpoint"] = input.AuthorizationEndpoint;
|
|
2559
2454
|
}
|
|
2560
|
-
if (input.TokenEndpoint
|
|
2455
|
+
if (input.TokenEndpoint != null) {
|
|
2561
2456
|
entries["TokenEndpoint"] = input.TokenEndpoint;
|
|
2562
2457
|
}
|
|
2563
|
-
if (input.UserInfoEndpoint
|
|
2458
|
+
if (input.UserInfoEndpoint != null) {
|
|
2564
2459
|
entries["UserInfoEndpoint"] = input.UserInfoEndpoint;
|
|
2565
2460
|
}
|
|
2566
|
-
if (input.ClientId
|
|
2461
|
+
if (input.ClientId != null) {
|
|
2567
2462
|
entries["ClientId"] = input.ClientId;
|
|
2568
2463
|
}
|
|
2569
|
-
if (input.ClientSecret
|
|
2464
|
+
if (input.ClientSecret != null) {
|
|
2570
2465
|
entries["ClientSecret"] = input.ClientSecret;
|
|
2571
2466
|
}
|
|
2572
|
-
if (input.SessionCookieName
|
|
2467
|
+
if (input.SessionCookieName != null) {
|
|
2573
2468
|
entries["SessionCookieName"] = input.SessionCookieName;
|
|
2574
2469
|
}
|
|
2575
|
-
if (input.Scope
|
|
2470
|
+
if (input.Scope != null) {
|
|
2576
2471
|
entries["Scope"] = input.Scope;
|
|
2577
2472
|
}
|
|
2578
|
-
if (input.SessionTimeout
|
|
2473
|
+
if (input.SessionTimeout != null) {
|
|
2579
2474
|
entries["SessionTimeout"] = input.SessionTimeout;
|
|
2580
2475
|
}
|
|
2581
|
-
if (input.AuthenticationRequestExtraParams
|
|
2476
|
+
if (input.AuthenticationRequestExtraParams != null) {
|
|
2582
2477
|
const memberEntries = serializeAws_queryAuthenticateOidcActionAuthenticationRequestExtraParams(input.AuthenticationRequestExtraParams, context);
|
|
2583
2478
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2584
2479
|
const loc = `AuthenticationRequestExtraParams.${key}`;
|
|
2585
2480
|
entries[loc] = value;
|
|
2586
2481
|
});
|
|
2587
2482
|
}
|
|
2588
|
-
if (input.OnUnauthenticatedRequest
|
|
2483
|
+
if (input.OnUnauthenticatedRequest != null) {
|
|
2589
2484
|
entries["OnUnauthenticatedRequest"] = input.OnUnauthenticatedRequest;
|
|
2590
2485
|
}
|
|
2591
|
-
if (input.UseExistingClientSecret
|
|
2486
|
+
if (input.UseExistingClientSecret != null) {
|
|
2592
2487
|
entries["UseExistingClientSecret"] = input.UseExistingClientSecret;
|
|
2593
2488
|
}
|
|
2594
2489
|
return entries;
|
|
2595
2490
|
};
|
|
2596
2491
|
const serializeAws_queryCertificate = (input, context) => {
|
|
2597
2492
|
const entries = {};
|
|
2598
|
-
if (input.CertificateArn
|
|
2493
|
+
if (input.CertificateArn != null) {
|
|
2599
2494
|
entries["CertificateArn"] = input.CertificateArn;
|
|
2600
2495
|
}
|
|
2601
|
-
if (input.IsDefault
|
|
2496
|
+
if (input.IsDefault != null) {
|
|
2602
2497
|
entries["IsDefault"] = input.IsDefault;
|
|
2603
2498
|
}
|
|
2604
2499
|
return entries;
|
|
@@ -2620,40 +2515,40 @@ const serializeAws_queryCertificateList = (input, context) => {
|
|
|
2620
2515
|
};
|
|
2621
2516
|
const serializeAws_queryCreateListenerInput = (input, context) => {
|
|
2622
2517
|
const entries = {};
|
|
2623
|
-
if (input.LoadBalancerArn
|
|
2518
|
+
if (input.LoadBalancerArn != null) {
|
|
2624
2519
|
entries["LoadBalancerArn"] = input.LoadBalancerArn;
|
|
2625
2520
|
}
|
|
2626
|
-
if (input.Protocol
|
|
2521
|
+
if (input.Protocol != null) {
|
|
2627
2522
|
entries["Protocol"] = input.Protocol;
|
|
2628
2523
|
}
|
|
2629
|
-
if (input.Port
|
|
2524
|
+
if (input.Port != null) {
|
|
2630
2525
|
entries["Port"] = input.Port;
|
|
2631
2526
|
}
|
|
2632
|
-
if (input.SslPolicy
|
|
2527
|
+
if (input.SslPolicy != null) {
|
|
2633
2528
|
entries["SslPolicy"] = input.SslPolicy;
|
|
2634
2529
|
}
|
|
2635
|
-
if (input.Certificates
|
|
2530
|
+
if (input.Certificates != null) {
|
|
2636
2531
|
const memberEntries = serializeAws_queryCertificateList(input.Certificates, context);
|
|
2637
2532
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2638
2533
|
const loc = `Certificates.${key}`;
|
|
2639
2534
|
entries[loc] = value;
|
|
2640
2535
|
});
|
|
2641
2536
|
}
|
|
2642
|
-
if (input.DefaultActions
|
|
2537
|
+
if (input.DefaultActions != null) {
|
|
2643
2538
|
const memberEntries = serializeAws_queryActions(input.DefaultActions, context);
|
|
2644
2539
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2645
2540
|
const loc = `DefaultActions.${key}`;
|
|
2646
2541
|
entries[loc] = value;
|
|
2647
2542
|
});
|
|
2648
2543
|
}
|
|
2649
|
-
if (input.AlpnPolicy
|
|
2544
|
+
if (input.AlpnPolicy != null) {
|
|
2650
2545
|
const memberEntries = serializeAws_queryAlpnPolicyName(input.AlpnPolicy, context);
|
|
2651
2546
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2652
2547
|
const loc = `AlpnPolicy.${key}`;
|
|
2653
2548
|
entries[loc] = value;
|
|
2654
2549
|
});
|
|
2655
2550
|
}
|
|
2656
|
-
if (input.Tags
|
|
2551
|
+
if (input.Tags != null) {
|
|
2657
2552
|
const memberEntries = serializeAws_queryTagList(input.Tags, context);
|
|
2658
2553
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2659
2554
|
const loc = `Tags.${key}`;
|
|
@@ -2664,74 +2559,74 @@ const serializeAws_queryCreateListenerInput = (input, context) => {
|
|
|
2664
2559
|
};
|
|
2665
2560
|
const serializeAws_queryCreateLoadBalancerInput = (input, context) => {
|
|
2666
2561
|
const entries = {};
|
|
2667
|
-
if (input.Name
|
|
2562
|
+
if (input.Name != null) {
|
|
2668
2563
|
entries["Name"] = input.Name;
|
|
2669
2564
|
}
|
|
2670
|
-
if (input.Subnets
|
|
2565
|
+
if (input.Subnets != null) {
|
|
2671
2566
|
const memberEntries = serializeAws_querySubnets(input.Subnets, context);
|
|
2672
2567
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2673
2568
|
const loc = `Subnets.${key}`;
|
|
2674
2569
|
entries[loc] = value;
|
|
2675
2570
|
});
|
|
2676
2571
|
}
|
|
2677
|
-
if (input.SubnetMappings
|
|
2572
|
+
if (input.SubnetMappings != null) {
|
|
2678
2573
|
const memberEntries = serializeAws_querySubnetMappings(input.SubnetMappings, context);
|
|
2679
2574
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2680
2575
|
const loc = `SubnetMappings.${key}`;
|
|
2681
2576
|
entries[loc] = value;
|
|
2682
2577
|
});
|
|
2683
2578
|
}
|
|
2684
|
-
if (input.SecurityGroups
|
|
2579
|
+
if (input.SecurityGroups != null) {
|
|
2685
2580
|
const memberEntries = serializeAws_querySecurityGroups(input.SecurityGroups, context);
|
|
2686
2581
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2687
2582
|
const loc = `SecurityGroups.${key}`;
|
|
2688
2583
|
entries[loc] = value;
|
|
2689
2584
|
});
|
|
2690
2585
|
}
|
|
2691
|
-
if (input.Scheme
|
|
2586
|
+
if (input.Scheme != null) {
|
|
2692
2587
|
entries["Scheme"] = input.Scheme;
|
|
2693
2588
|
}
|
|
2694
|
-
if (input.Tags
|
|
2589
|
+
if (input.Tags != null) {
|
|
2695
2590
|
const memberEntries = serializeAws_queryTagList(input.Tags, context);
|
|
2696
2591
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2697
2592
|
const loc = `Tags.${key}`;
|
|
2698
2593
|
entries[loc] = value;
|
|
2699
2594
|
});
|
|
2700
2595
|
}
|
|
2701
|
-
if (input.Type
|
|
2596
|
+
if (input.Type != null) {
|
|
2702
2597
|
entries["Type"] = input.Type;
|
|
2703
2598
|
}
|
|
2704
|
-
if (input.IpAddressType
|
|
2599
|
+
if (input.IpAddressType != null) {
|
|
2705
2600
|
entries["IpAddressType"] = input.IpAddressType;
|
|
2706
2601
|
}
|
|
2707
|
-
if (input.CustomerOwnedIpv4Pool
|
|
2602
|
+
if (input.CustomerOwnedIpv4Pool != null) {
|
|
2708
2603
|
entries["CustomerOwnedIpv4Pool"] = input.CustomerOwnedIpv4Pool;
|
|
2709
2604
|
}
|
|
2710
2605
|
return entries;
|
|
2711
2606
|
};
|
|
2712
2607
|
const serializeAws_queryCreateRuleInput = (input, context) => {
|
|
2713
2608
|
const entries = {};
|
|
2714
|
-
if (input.ListenerArn
|
|
2609
|
+
if (input.ListenerArn != null) {
|
|
2715
2610
|
entries["ListenerArn"] = input.ListenerArn;
|
|
2716
2611
|
}
|
|
2717
|
-
if (input.Conditions
|
|
2612
|
+
if (input.Conditions != null) {
|
|
2718
2613
|
const memberEntries = serializeAws_queryRuleConditionList(input.Conditions, context);
|
|
2719
2614
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2720
2615
|
const loc = `Conditions.${key}`;
|
|
2721
2616
|
entries[loc] = value;
|
|
2722
2617
|
});
|
|
2723
2618
|
}
|
|
2724
|
-
if (input.Priority
|
|
2619
|
+
if (input.Priority != null) {
|
|
2725
2620
|
entries["Priority"] = input.Priority;
|
|
2726
2621
|
}
|
|
2727
|
-
if (input.Actions
|
|
2622
|
+
if (input.Actions != null) {
|
|
2728
2623
|
const memberEntries = serializeAws_queryActions(input.Actions, context);
|
|
2729
2624
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2730
2625
|
const loc = `Actions.${key}`;
|
|
2731
2626
|
entries[loc] = value;
|
|
2732
2627
|
});
|
|
2733
2628
|
}
|
|
2734
|
-
if (input.Tags
|
|
2629
|
+
if (input.Tags != null) {
|
|
2735
2630
|
const memberEntries = serializeAws_queryTagList(input.Tags, context);
|
|
2736
2631
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2737
2632
|
const loc = `Tags.${key}`;
|
|
@@ -2742,101 +2637,101 @@ const serializeAws_queryCreateRuleInput = (input, context) => {
|
|
|
2742
2637
|
};
|
|
2743
2638
|
const serializeAws_queryCreateTargetGroupInput = (input, context) => {
|
|
2744
2639
|
const entries = {};
|
|
2745
|
-
if (input.Name
|
|
2640
|
+
if (input.Name != null) {
|
|
2746
2641
|
entries["Name"] = input.Name;
|
|
2747
2642
|
}
|
|
2748
|
-
if (input.Protocol
|
|
2643
|
+
if (input.Protocol != null) {
|
|
2749
2644
|
entries["Protocol"] = input.Protocol;
|
|
2750
2645
|
}
|
|
2751
|
-
if (input.ProtocolVersion
|
|
2646
|
+
if (input.ProtocolVersion != null) {
|
|
2752
2647
|
entries["ProtocolVersion"] = input.ProtocolVersion;
|
|
2753
2648
|
}
|
|
2754
|
-
if (input.Port
|
|
2649
|
+
if (input.Port != null) {
|
|
2755
2650
|
entries["Port"] = input.Port;
|
|
2756
2651
|
}
|
|
2757
|
-
if (input.VpcId
|
|
2652
|
+
if (input.VpcId != null) {
|
|
2758
2653
|
entries["VpcId"] = input.VpcId;
|
|
2759
2654
|
}
|
|
2760
|
-
if (input.HealthCheckProtocol
|
|
2655
|
+
if (input.HealthCheckProtocol != null) {
|
|
2761
2656
|
entries["HealthCheckProtocol"] = input.HealthCheckProtocol;
|
|
2762
2657
|
}
|
|
2763
|
-
if (input.HealthCheckPort
|
|
2658
|
+
if (input.HealthCheckPort != null) {
|
|
2764
2659
|
entries["HealthCheckPort"] = input.HealthCheckPort;
|
|
2765
2660
|
}
|
|
2766
|
-
if (input.HealthCheckEnabled
|
|
2661
|
+
if (input.HealthCheckEnabled != null) {
|
|
2767
2662
|
entries["HealthCheckEnabled"] = input.HealthCheckEnabled;
|
|
2768
2663
|
}
|
|
2769
|
-
if (input.HealthCheckPath
|
|
2664
|
+
if (input.HealthCheckPath != null) {
|
|
2770
2665
|
entries["HealthCheckPath"] = input.HealthCheckPath;
|
|
2771
2666
|
}
|
|
2772
|
-
if (input.HealthCheckIntervalSeconds
|
|
2667
|
+
if (input.HealthCheckIntervalSeconds != null) {
|
|
2773
2668
|
entries["HealthCheckIntervalSeconds"] = input.HealthCheckIntervalSeconds;
|
|
2774
2669
|
}
|
|
2775
|
-
if (input.HealthCheckTimeoutSeconds
|
|
2670
|
+
if (input.HealthCheckTimeoutSeconds != null) {
|
|
2776
2671
|
entries["HealthCheckTimeoutSeconds"] = input.HealthCheckTimeoutSeconds;
|
|
2777
2672
|
}
|
|
2778
|
-
if (input.HealthyThresholdCount
|
|
2673
|
+
if (input.HealthyThresholdCount != null) {
|
|
2779
2674
|
entries["HealthyThresholdCount"] = input.HealthyThresholdCount;
|
|
2780
2675
|
}
|
|
2781
|
-
if (input.UnhealthyThresholdCount
|
|
2676
|
+
if (input.UnhealthyThresholdCount != null) {
|
|
2782
2677
|
entries["UnhealthyThresholdCount"] = input.UnhealthyThresholdCount;
|
|
2783
2678
|
}
|
|
2784
|
-
if (input.Matcher
|
|
2679
|
+
if (input.Matcher != null) {
|
|
2785
2680
|
const memberEntries = serializeAws_queryMatcher(input.Matcher, context);
|
|
2786
2681
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2787
2682
|
const loc = `Matcher.${key}`;
|
|
2788
2683
|
entries[loc] = value;
|
|
2789
2684
|
});
|
|
2790
2685
|
}
|
|
2791
|
-
if (input.TargetType
|
|
2686
|
+
if (input.TargetType != null) {
|
|
2792
2687
|
entries["TargetType"] = input.TargetType;
|
|
2793
2688
|
}
|
|
2794
|
-
if (input.Tags
|
|
2689
|
+
if (input.Tags != null) {
|
|
2795
2690
|
const memberEntries = serializeAws_queryTagList(input.Tags, context);
|
|
2796
2691
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2797
2692
|
const loc = `Tags.${key}`;
|
|
2798
2693
|
entries[loc] = value;
|
|
2799
2694
|
});
|
|
2800
2695
|
}
|
|
2801
|
-
if (input.IpAddressType
|
|
2696
|
+
if (input.IpAddressType != null) {
|
|
2802
2697
|
entries["IpAddressType"] = input.IpAddressType;
|
|
2803
2698
|
}
|
|
2804
2699
|
return entries;
|
|
2805
2700
|
};
|
|
2806
2701
|
const serializeAws_queryDeleteListenerInput = (input, context) => {
|
|
2807
2702
|
const entries = {};
|
|
2808
|
-
if (input.ListenerArn
|
|
2703
|
+
if (input.ListenerArn != null) {
|
|
2809
2704
|
entries["ListenerArn"] = input.ListenerArn;
|
|
2810
2705
|
}
|
|
2811
2706
|
return entries;
|
|
2812
2707
|
};
|
|
2813
2708
|
const serializeAws_queryDeleteLoadBalancerInput = (input, context) => {
|
|
2814
2709
|
const entries = {};
|
|
2815
|
-
if (input.LoadBalancerArn
|
|
2710
|
+
if (input.LoadBalancerArn != null) {
|
|
2816
2711
|
entries["LoadBalancerArn"] = input.LoadBalancerArn;
|
|
2817
2712
|
}
|
|
2818
2713
|
return entries;
|
|
2819
2714
|
};
|
|
2820
2715
|
const serializeAws_queryDeleteRuleInput = (input, context) => {
|
|
2821
2716
|
const entries = {};
|
|
2822
|
-
if (input.RuleArn
|
|
2717
|
+
if (input.RuleArn != null) {
|
|
2823
2718
|
entries["RuleArn"] = input.RuleArn;
|
|
2824
2719
|
}
|
|
2825
2720
|
return entries;
|
|
2826
2721
|
};
|
|
2827
2722
|
const serializeAws_queryDeleteTargetGroupInput = (input, context) => {
|
|
2828
2723
|
const entries = {};
|
|
2829
|
-
if (input.TargetGroupArn
|
|
2724
|
+
if (input.TargetGroupArn != null) {
|
|
2830
2725
|
entries["TargetGroupArn"] = input.TargetGroupArn;
|
|
2831
2726
|
}
|
|
2832
2727
|
return entries;
|
|
2833
2728
|
};
|
|
2834
2729
|
const serializeAws_queryDeregisterTargetsInput = (input, context) => {
|
|
2835
2730
|
const entries = {};
|
|
2836
|
-
if (input.TargetGroupArn
|
|
2731
|
+
if (input.TargetGroupArn != null) {
|
|
2837
2732
|
entries["TargetGroupArn"] = input.TargetGroupArn;
|
|
2838
2733
|
}
|
|
2839
|
-
if (input.Targets
|
|
2734
|
+
if (input.Targets != null) {
|
|
2840
2735
|
const memberEntries = serializeAws_queryTargetDescriptions(input.Targets, context);
|
|
2841
2736
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2842
2737
|
const loc = `Targets.${key}`;
|
|
@@ -2847,121 +2742,121 @@ const serializeAws_queryDeregisterTargetsInput = (input, context) => {
|
|
|
2847
2742
|
};
|
|
2848
2743
|
const serializeAws_queryDescribeAccountLimitsInput = (input, context) => {
|
|
2849
2744
|
const entries = {};
|
|
2850
|
-
if (input.Marker
|
|
2745
|
+
if (input.Marker != null) {
|
|
2851
2746
|
entries["Marker"] = input.Marker;
|
|
2852
2747
|
}
|
|
2853
|
-
if (input.PageSize
|
|
2748
|
+
if (input.PageSize != null) {
|
|
2854
2749
|
entries["PageSize"] = input.PageSize;
|
|
2855
2750
|
}
|
|
2856
2751
|
return entries;
|
|
2857
2752
|
};
|
|
2858
2753
|
const serializeAws_queryDescribeListenerCertificatesInput = (input, context) => {
|
|
2859
2754
|
const entries = {};
|
|
2860
|
-
if (input.ListenerArn
|
|
2755
|
+
if (input.ListenerArn != null) {
|
|
2861
2756
|
entries["ListenerArn"] = input.ListenerArn;
|
|
2862
2757
|
}
|
|
2863
|
-
if (input.Marker
|
|
2758
|
+
if (input.Marker != null) {
|
|
2864
2759
|
entries["Marker"] = input.Marker;
|
|
2865
2760
|
}
|
|
2866
|
-
if (input.PageSize
|
|
2761
|
+
if (input.PageSize != null) {
|
|
2867
2762
|
entries["PageSize"] = input.PageSize;
|
|
2868
2763
|
}
|
|
2869
2764
|
return entries;
|
|
2870
2765
|
};
|
|
2871
2766
|
const serializeAws_queryDescribeListenersInput = (input, context) => {
|
|
2872
2767
|
const entries = {};
|
|
2873
|
-
if (input.LoadBalancerArn
|
|
2768
|
+
if (input.LoadBalancerArn != null) {
|
|
2874
2769
|
entries["LoadBalancerArn"] = input.LoadBalancerArn;
|
|
2875
2770
|
}
|
|
2876
|
-
if (input.ListenerArns
|
|
2771
|
+
if (input.ListenerArns != null) {
|
|
2877
2772
|
const memberEntries = serializeAws_queryListenerArns(input.ListenerArns, context);
|
|
2878
2773
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2879
2774
|
const loc = `ListenerArns.${key}`;
|
|
2880
2775
|
entries[loc] = value;
|
|
2881
2776
|
});
|
|
2882
2777
|
}
|
|
2883
|
-
if (input.Marker
|
|
2778
|
+
if (input.Marker != null) {
|
|
2884
2779
|
entries["Marker"] = input.Marker;
|
|
2885
2780
|
}
|
|
2886
|
-
if (input.PageSize
|
|
2781
|
+
if (input.PageSize != null) {
|
|
2887
2782
|
entries["PageSize"] = input.PageSize;
|
|
2888
2783
|
}
|
|
2889
2784
|
return entries;
|
|
2890
2785
|
};
|
|
2891
2786
|
const serializeAws_queryDescribeLoadBalancerAttributesInput = (input, context) => {
|
|
2892
2787
|
const entries = {};
|
|
2893
|
-
if (input.LoadBalancerArn
|
|
2788
|
+
if (input.LoadBalancerArn != null) {
|
|
2894
2789
|
entries["LoadBalancerArn"] = input.LoadBalancerArn;
|
|
2895
2790
|
}
|
|
2896
2791
|
return entries;
|
|
2897
2792
|
};
|
|
2898
2793
|
const serializeAws_queryDescribeLoadBalancersInput = (input, context) => {
|
|
2899
2794
|
const entries = {};
|
|
2900
|
-
if (input.LoadBalancerArns
|
|
2795
|
+
if (input.LoadBalancerArns != null) {
|
|
2901
2796
|
const memberEntries = serializeAws_queryLoadBalancerArns(input.LoadBalancerArns, context);
|
|
2902
2797
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2903
2798
|
const loc = `LoadBalancerArns.${key}`;
|
|
2904
2799
|
entries[loc] = value;
|
|
2905
2800
|
});
|
|
2906
2801
|
}
|
|
2907
|
-
if (input.Names
|
|
2802
|
+
if (input.Names != null) {
|
|
2908
2803
|
const memberEntries = serializeAws_queryLoadBalancerNames(input.Names, context);
|
|
2909
2804
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2910
2805
|
const loc = `Names.${key}`;
|
|
2911
2806
|
entries[loc] = value;
|
|
2912
2807
|
});
|
|
2913
2808
|
}
|
|
2914
|
-
if (input.Marker
|
|
2809
|
+
if (input.Marker != null) {
|
|
2915
2810
|
entries["Marker"] = input.Marker;
|
|
2916
2811
|
}
|
|
2917
|
-
if (input.PageSize
|
|
2812
|
+
if (input.PageSize != null) {
|
|
2918
2813
|
entries["PageSize"] = input.PageSize;
|
|
2919
2814
|
}
|
|
2920
2815
|
return entries;
|
|
2921
2816
|
};
|
|
2922
2817
|
const serializeAws_queryDescribeRulesInput = (input, context) => {
|
|
2923
2818
|
const entries = {};
|
|
2924
|
-
if (input.ListenerArn
|
|
2819
|
+
if (input.ListenerArn != null) {
|
|
2925
2820
|
entries["ListenerArn"] = input.ListenerArn;
|
|
2926
2821
|
}
|
|
2927
|
-
if (input.RuleArns
|
|
2822
|
+
if (input.RuleArns != null) {
|
|
2928
2823
|
const memberEntries = serializeAws_queryRuleArns(input.RuleArns, context);
|
|
2929
2824
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2930
2825
|
const loc = `RuleArns.${key}`;
|
|
2931
2826
|
entries[loc] = value;
|
|
2932
2827
|
});
|
|
2933
2828
|
}
|
|
2934
|
-
if (input.Marker
|
|
2829
|
+
if (input.Marker != null) {
|
|
2935
2830
|
entries["Marker"] = input.Marker;
|
|
2936
2831
|
}
|
|
2937
|
-
if (input.PageSize
|
|
2832
|
+
if (input.PageSize != null) {
|
|
2938
2833
|
entries["PageSize"] = input.PageSize;
|
|
2939
2834
|
}
|
|
2940
2835
|
return entries;
|
|
2941
2836
|
};
|
|
2942
2837
|
const serializeAws_queryDescribeSSLPoliciesInput = (input, context) => {
|
|
2943
2838
|
const entries = {};
|
|
2944
|
-
if (input.Names
|
|
2839
|
+
if (input.Names != null) {
|
|
2945
2840
|
const memberEntries = serializeAws_querySslPolicyNames(input.Names, context);
|
|
2946
2841
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2947
2842
|
const loc = `Names.${key}`;
|
|
2948
2843
|
entries[loc] = value;
|
|
2949
2844
|
});
|
|
2950
2845
|
}
|
|
2951
|
-
if (input.Marker
|
|
2846
|
+
if (input.Marker != null) {
|
|
2952
2847
|
entries["Marker"] = input.Marker;
|
|
2953
2848
|
}
|
|
2954
|
-
if (input.PageSize
|
|
2849
|
+
if (input.PageSize != null) {
|
|
2955
2850
|
entries["PageSize"] = input.PageSize;
|
|
2956
2851
|
}
|
|
2957
|
-
if (input.LoadBalancerType
|
|
2852
|
+
if (input.LoadBalancerType != null) {
|
|
2958
2853
|
entries["LoadBalancerType"] = input.LoadBalancerType;
|
|
2959
2854
|
}
|
|
2960
2855
|
return entries;
|
|
2961
2856
|
};
|
|
2962
2857
|
const serializeAws_queryDescribeTagsInput = (input, context) => {
|
|
2963
2858
|
const entries = {};
|
|
2964
|
-
if (input.ResourceArns
|
|
2859
|
+
if (input.ResourceArns != null) {
|
|
2965
2860
|
const memberEntries = serializeAws_queryResourceArns(input.ResourceArns, context);
|
|
2966
2861
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2967
2862
|
const loc = `ResourceArns.${key}`;
|
|
@@ -2972,44 +2867,44 @@ const serializeAws_queryDescribeTagsInput = (input, context) => {
|
|
|
2972
2867
|
};
|
|
2973
2868
|
const serializeAws_queryDescribeTargetGroupAttributesInput = (input, context) => {
|
|
2974
2869
|
const entries = {};
|
|
2975
|
-
if (input.TargetGroupArn
|
|
2870
|
+
if (input.TargetGroupArn != null) {
|
|
2976
2871
|
entries["TargetGroupArn"] = input.TargetGroupArn;
|
|
2977
2872
|
}
|
|
2978
2873
|
return entries;
|
|
2979
2874
|
};
|
|
2980
2875
|
const serializeAws_queryDescribeTargetGroupsInput = (input, context) => {
|
|
2981
2876
|
const entries = {};
|
|
2982
|
-
if (input.LoadBalancerArn
|
|
2877
|
+
if (input.LoadBalancerArn != null) {
|
|
2983
2878
|
entries["LoadBalancerArn"] = input.LoadBalancerArn;
|
|
2984
2879
|
}
|
|
2985
|
-
if (input.TargetGroupArns
|
|
2880
|
+
if (input.TargetGroupArns != null) {
|
|
2986
2881
|
const memberEntries = serializeAws_queryTargetGroupArns(input.TargetGroupArns, context);
|
|
2987
2882
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2988
2883
|
const loc = `TargetGroupArns.${key}`;
|
|
2989
2884
|
entries[loc] = value;
|
|
2990
2885
|
});
|
|
2991
2886
|
}
|
|
2992
|
-
if (input.Names
|
|
2887
|
+
if (input.Names != null) {
|
|
2993
2888
|
const memberEntries = serializeAws_queryTargetGroupNames(input.Names, context);
|
|
2994
2889
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
2995
2890
|
const loc = `Names.${key}`;
|
|
2996
2891
|
entries[loc] = value;
|
|
2997
2892
|
});
|
|
2998
2893
|
}
|
|
2999
|
-
if (input.Marker
|
|
2894
|
+
if (input.Marker != null) {
|
|
3000
2895
|
entries["Marker"] = input.Marker;
|
|
3001
2896
|
}
|
|
3002
|
-
if (input.PageSize
|
|
2897
|
+
if (input.PageSize != null) {
|
|
3003
2898
|
entries["PageSize"] = input.PageSize;
|
|
3004
2899
|
}
|
|
3005
2900
|
return entries;
|
|
3006
2901
|
};
|
|
3007
2902
|
const serializeAws_queryDescribeTargetHealthInput = (input, context) => {
|
|
3008
2903
|
const entries = {};
|
|
3009
|
-
if (input.TargetGroupArn
|
|
2904
|
+
if (input.TargetGroupArn != null) {
|
|
3010
2905
|
entries["TargetGroupArn"] = input.TargetGroupArn;
|
|
3011
2906
|
}
|
|
3012
|
-
if (input.Targets
|
|
2907
|
+
if (input.Targets != null) {
|
|
3013
2908
|
const memberEntries = serializeAws_queryTargetDescriptions(input.Targets, context);
|
|
3014
2909
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3015
2910
|
const loc = `Targets.${key}`;
|
|
@@ -3020,27 +2915,27 @@ const serializeAws_queryDescribeTargetHealthInput = (input, context) => {
|
|
|
3020
2915
|
};
|
|
3021
2916
|
const serializeAws_queryFixedResponseActionConfig = (input, context) => {
|
|
3022
2917
|
const entries = {};
|
|
3023
|
-
if (input.MessageBody
|
|
2918
|
+
if (input.MessageBody != null) {
|
|
3024
2919
|
entries["MessageBody"] = input.MessageBody;
|
|
3025
2920
|
}
|
|
3026
|
-
if (input.StatusCode
|
|
2921
|
+
if (input.StatusCode != null) {
|
|
3027
2922
|
entries["StatusCode"] = input.StatusCode;
|
|
3028
2923
|
}
|
|
3029
|
-
if (input.ContentType
|
|
2924
|
+
if (input.ContentType != null) {
|
|
3030
2925
|
entries["ContentType"] = input.ContentType;
|
|
3031
2926
|
}
|
|
3032
2927
|
return entries;
|
|
3033
2928
|
};
|
|
3034
2929
|
const serializeAws_queryForwardActionConfig = (input, context) => {
|
|
3035
2930
|
const entries = {};
|
|
3036
|
-
if (input.TargetGroups
|
|
2931
|
+
if (input.TargetGroups != null) {
|
|
3037
2932
|
const memberEntries = serializeAws_queryTargetGroupList(input.TargetGroups, context);
|
|
3038
2933
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3039
2934
|
const loc = `TargetGroups.${key}`;
|
|
3040
2935
|
entries[loc] = value;
|
|
3041
2936
|
});
|
|
3042
2937
|
}
|
|
3043
|
-
if (input.TargetGroupStickinessConfig
|
|
2938
|
+
if (input.TargetGroupStickinessConfig != null) {
|
|
3044
2939
|
const memberEntries = serializeAws_queryTargetGroupStickinessConfig(input.TargetGroupStickinessConfig, context);
|
|
3045
2940
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3046
2941
|
const loc = `TargetGroupStickinessConfig.${key}`;
|
|
@@ -3051,7 +2946,7 @@ const serializeAws_queryForwardActionConfig = (input, context) => {
|
|
|
3051
2946
|
};
|
|
3052
2947
|
const serializeAws_queryHostHeaderConditionConfig = (input, context) => {
|
|
3053
2948
|
const entries = {};
|
|
3054
|
-
if (input.Values
|
|
2949
|
+
if (input.Values != null) {
|
|
3055
2950
|
const memberEntries = serializeAws_queryListOfString(input.Values, context);
|
|
3056
2951
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3057
2952
|
const loc = `Values.${key}`;
|
|
@@ -3062,10 +2957,10 @@ const serializeAws_queryHostHeaderConditionConfig = (input, context) => {
|
|
|
3062
2957
|
};
|
|
3063
2958
|
const serializeAws_queryHttpHeaderConditionConfig = (input, context) => {
|
|
3064
2959
|
const entries = {};
|
|
3065
|
-
if (input.HttpHeaderName
|
|
2960
|
+
if (input.HttpHeaderName != null) {
|
|
3066
2961
|
entries["HttpHeaderName"] = input.HttpHeaderName;
|
|
3067
2962
|
}
|
|
3068
|
-
if (input.Values
|
|
2963
|
+
if (input.Values != null) {
|
|
3069
2964
|
const memberEntries = serializeAws_queryListOfString(input.Values, context);
|
|
3070
2965
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3071
2966
|
const loc = `Values.${key}`;
|
|
@@ -3076,7 +2971,7 @@ const serializeAws_queryHttpHeaderConditionConfig = (input, context) => {
|
|
|
3076
2971
|
};
|
|
3077
2972
|
const serializeAws_queryHttpRequestMethodConditionConfig = (input, context) => {
|
|
3078
2973
|
const entries = {};
|
|
3079
|
-
if (input.Values
|
|
2974
|
+
if (input.Values != null) {
|
|
3080
2975
|
const memberEntries = serializeAws_queryListOfString(input.Values, context);
|
|
3081
2976
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3082
2977
|
const loc = `Values.${key}`;
|
|
@@ -3123,10 +3018,10 @@ const serializeAws_queryLoadBalancerArns = (input, context) => {
|
|
|
3123
3018
|
};
|
|
3124
3019
|
const serializeAws_queryLoadBalancerAttribute = (input, context) => {
|
|
3125
3020
|
const entries = {};
|
|
3126
|
-
if (input.Key
|
|
3021
|
+
if (input.Key != null) {
|
|
3127
3022
|
entries["Key"] = input.Key;
|
|
3128
3023
|
}
|
|
3129
|
-
if (input.Value
|
|
3024
|
+
if (input.Value != null) {
|
|
3130
3025
|
entries["Value"] = input.Value;
|
|
3131
3026
|
}
|
|
3132
3027
|
return entries;
|
|
@@ -3160,43 +3055,43 @@ const serializeAws_queryLoadBalancerNames = (input, context) => {
|
|
|
3160
3055
|
};
|
|
3161
3056
|
const serializeAws_queryMatcher = (input, context) => {
|
|
3162
3057
|
const entries = {};
|
|
3163
|
-
if (input.HttpCode
|
|
3058
|
+
if (input.HttpCode != null) {
|
|
3164
3059
|
entries["HttpCode"] = input.HttpCode;
|
|
3165
3060
|
}
|
|
3166
|
-
if (input.GrpcCode
|
|
3061
|
+
if (input.GrpcCode != null) {
|
|
3167
3062
|
entries["GrpcCode"] = input.GrpcCode;
|
|
3168
3063
|
}
|
|
3169
3064
|
return entries;
|
|
3170
3065
|
};
|
|
3171
3066
|
const serializeAws_queryModifyListenerInput = (input, context) => {
|
|
3172
3067
|
const entries = {};
|
|
3173
|
-
if (input.ListenerArn
|
|
3068
|
+
if (input.ListenerArn != null) {
|
|
3174
3069
|
entries["ListenerArn"] = input.ListenerArn;
|
|
3175
3070
|
}
|
|
3176
|
-
if (input.Port
|
|
3071
|
+
if (input.Port != null) {
|
|
3177
3072
|
entries["Port"] = input.Port;
|
|
3178
3073
|
}
|
|
3179
|
-
if (input.Protocol
|
|
3074
|
+
if (input.Protocol != null) {
|
|
3180
3075
|
entries["Protocol"] = input.Protocol;
|
|
3181
3076
|
}
|
|
3182
|
-
if (input.SslPolicy
|
|
3077
|
+
if (input.SslPolicy != null) {
|
|
3183
3078
|
entries["SslPolicy"] = input.SslPolicy;
|
|
3184
3079
|
}
|
|
3185
|
-
if (input.Certificates
|
|
3080
|
+
if (input.Certificates != null) {
|
|
3186
3081
|
const memberEntries = serializeAws_queryCertificateList(input.Certificates, context);
|
|
3187
3082
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3188
3083
|
const loc = `Certificates.${key}`;
|
|
3189
3084
|
entries[loc] = value;
|
|
3190
3085
|
});
|
|
3191
3086
|
}
|
|
3192
|
-
if (input.DefaultActions
|
|
3087
|
+
if (input.DefaultActions != null) {
|
|
3193
3088
|
const memberEntries = serializeAws_queryActions(input.DefaultActions, context);
|
|
3194
3089
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3195
3090
|
const loc = `DefaultActions.${key}`;
|
|
3196
3091
|
entries[loc] = value;
|
|
3197
3092
|
});
|
|
3198
3093
|
}
|
|
3199
|
-
if (input.AlpnPolicy
|
|
3094
|
+
if (input.AlpnPolicy != null) {
|
|
3200
3095
|
const memberEntries = serializeAws_queryAlpnPolicyName(input.AlpnPolicy, context);
|
|
3201
3096
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3202
3097
|
const loc = `AlpnPolicy.${key}`;
|
|
@@ -3207,10 +3102,10 @@ const serializeAws_queryModifyListenerInput = (input, context) => {
|
|
|
3207
3102
|
};
|
|
3208
3103
|
const serializeAws_queryModifyLoadBalancerAttributesInput = (input, context) => {
|
|
3209
3104
|
const entries = {};
|
|
3210
|
-
if (input.LoadBalancerArn
|
|
3105
|
+
if (input.LoadBalancerArn != null) {
|
|
3211
3106
|
entries["LoadBalancerArn"] = input.LoadBalancerArn;
|
|
3212
3107
|
}
|
|
3213
|
-
if (input.Attributes
|
|
3108
|
+
if (input.Attributes != null) {
|
|
3214
3109
|
const memberEntries = serializeAws_queryLoadBalancerAttributes(input.Attributes, context);
|
|
3215
3110
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3216
3111
|
const loc = `Attributes.${key}`;
|
|
@@ -3221,17 +3116,17 @@ const serializeAws_queryModifyLoadBalancerAttributesInput = (input, context) =>
|
|
|
3221
3116
|
};
|
|
3222
3117
|
const serializeAws_queryModifyRuleInput = (input, context) => {
|
|
3223
3118
|
const entries = {};
|
|
3224
|
-
if (input.RuleArn
|
|
3119
|
+
if (input.RuleArn != null) {
|
|
3225
3120
|
entries["RuleArn"] = input.RuleArn;
|
|
3226
3121
|
}
|
|
3227
|
-
if (input.Conditions
|
|
3122
|
+
if (input.Conditions != null) {
|
|
3228
3123
|
const memberEntries = serializeAws_queryRuleConditionList(input.Conditions, context);
|
|
3229
3124
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3230
3125
|
const loc = `Conditions.${key}`;
|
|
3231
3126
|
entries[loc] = value;
|
|
3232
3127
|
});
|
|
3233
3128
|
}
|
|
3234
|
-
if (input.Actions
|
|
3129
|
+
if (input.Actions != null) {
|
|
3235
3130
|
const memberEntries = serializeAws_queryActions(input.Actions, context);
|
|
3236
3131
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3237
3132
|
const loc = `Actions.${key}`;
|
|
@@ -3242,10 +3137,10 @@ const serializeAws_queryModifyRuleInput = (input, context) => {
|
|
|
3242
3137
|
};
|
|
3243
3138
|
const serializeAws_queryModifyTargetGroupAttributesInput = (input, context) => {
|
|
3244
3139
|
const entries = {};
|
|
3245
|
-
if (input.TargetGroupArn
|
|
3140
|
+
if (input.TargetGroupArn != null) {
|
|
3246
3141
|
entries["TargetGroupArn"] = input.TargetGroupArn;
|
|
3247
3142
|
}
|
|
3248
|
-
if (input.Attributes
|
|
3143
|
+
if (input.Attributes != null) {
|
|
3249
3144
|
const memberEntries = serializeAws_queryTargetGroupAttributes(input.Attributes, context);
|
|
3250
3145
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3251
3146
|
const loc = `Attributes.${key}`;
|
|
@@ -3256,34 +3151,34 @@ const serializeAws_queryModifyTargetGroupAttributesInput = (input, context) => {
|
|
|
3256
3151
|
};
|
|
3257
3152
|
const serializeAws_queryModifyTargetGroupInput = (input, context) => {
|
|
3258
3153
|
const entries = {};
|
|
3259
|
-
if (input.TargetGroupArn
|
|
3154
|
+
if (input.TargetGroupArn != null) {
|
|
3260
3155
|
entries["TargetGroupArn"] = input.TargetGroupArn;
|
|
3261
3156
|
}
|
|
3262
|
-
if (input.HealthCheckProtocol
|
|
3157
|
+
if (input.HealthCheckProtocol != null) {
|
|
3263
3158
|
entries["HealthCheckProtocol"] = input.HealthCheckProtocol;
|
|
3264
3159
|
}
|
|
3265
|
-
if (input.HealthCheckPort
|
|
3160
|
+
if (input.HealthCheckPort != null) {
|
|
3266
3161
|
entries["HealthCheckPort"] = input.HealthCheckPort;
|
|
3267
3162
|
}
|
|
3268
|
-
if (input.HealthCheckPath
|
|
3163
|
+
if (input.HealthCheckPath != null) {
|
|
3269
3164
|
entries["HealthCheckPath"] = input.HealthCheckPath;
|
|
3270
3165
|
}
|
|
3271
|
-
if (input.HealthCheckEnabled
|
|
3166
|
+
if (input.HealthCheckEnabled != null) {
|
|
3272
3167
|
entries["HealthCheckEnabled"] = input.HealthCheckEnabled;
|
|
3273
3168
|
}
|
|
3274
|
-
if (input.HealthCheckIntervalSeconds
|
|
3169
|
+
if (input.HealthCheckIntervalSeconds != null) {
|
|
3275
3170
|
entries["HealthCheckIntervalSeconds"] = input.HealthCheckIntervalSeconds;
|
|
3276
3171
|
}
|
|
3277
|
-
if (input.HealthCheckTimeoutSeconds
|
|
3172
|
+
if (input.HealthCheckTimeoutSeconds != null) {
|
|
3278
3173
|
entries["HealthCheckTimeoutSeconds"] = input.HealthCheckTimeoutSeconds;
|
|
3279
3174
|
}
|
|
3280
|
-
if (input.HealthyThresholdCount
|
|
3175
|
+
if (input.HealthyThresholdCount != null) {
|
|
3281
3176
|
entries["HealthyThresholdCount"] = input.HealthyThresholdCount;
|
|
3282
3177
|
}
|
|
3283
|
-
if (input.UnhealthyThresholdCount
|
|
3178
|
+
if (input.UnhealthyThresholdCount != null) {
|
|
3284
3179
|
entries["UnhealthyThresholdCount"] = input.UnhealthyThresholdCount;
|
|
3285
3180
|
}
|
|
3286
|
-
if (input.Matcher
|
|
3181
|
+
if (input.Matcher != null) {
|
|
3287
3182
|
const memberEntries = serializeAws_queryMatcher(input.Matcher, context);
|
|
3288
3183
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3289
3184
|
const loc = `Matcher.${key}`;
|
|
@@ -3294,7 +3189,7 @@ const serializeAws_queryModifyTargetGroupInput = (input, context) => {
|
|
|
3294
3189
|
};
|
|
3295
3190
|
const serializeAws_queryPathPatternConditionConfig = (input, context) => {
|
|
3296
3191
|
const entries = {};
|
|
3297
|
-
if (input.Values
|
|
3192
|
+
if (input.Values != null) {
|
|
3298
3193
|
const memberEntries = serializeAws_queryListOfString(input.Values, context);
|
|
3299
3194
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3300
3195
|
const loc = `Values.${key}`;
|
|
@@ -3305,7 +3200,7 @@ const serializeAws_queryPathPatternConditionConfig = (input, context) => {
|
|
|
3305
3200
|
};
|
|
3306
3201
|
const serializeAws_queryQueryStringConditionConfig = (input, context) => {
|
|
3307
3202
|
const entries = {};
|
|
3308
|
-
if (input.Values
|
|
3203
|
+
if (input.Values != null) {
|
|
3309
3204
|
const memberEntries = serializeAws_queryQueryStringKeyValuePairList(input.Values, context);
|
|
3310
3205
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3311
3206
|
const loc = `Values.${key}`;
|
|
@@ -3316,10 +3211,10 @@ const serializeAws_queryQueryStringConditionConfig = (input, context) => {
|
|
|
3316
3211
|
};
|
|
3317
3212
|
const serializeAws_queryQueryStringKeyValuePair = (input, context) => {
|
|
3318
3213
|
const entries = {};
|
|
3319
|
-
if (input.Key
|
|
3214
|
+
if (input.Key != null) {
|
|
3320
3215
|
entries["Key"] = input.Key;
|
|
3321
3216
|
}
|
|
3322
|
-
if (input.Value
|
|
3217
|
+
if (input.Value != null) {
|
|
3323
3218
|
entries["Value"] = input.Value;
|
|
3324
3219
|
}
|
|
3325
3220
|
return entries;
|
|
@@ -3341,32 +3236,32 @@ const serializeAws_queryQueryStringKeyValuePairList = (input, context) => {
|
|
|
3341
3236
|
};
|
|
3342
3237
|
const serializeAws_queryRedirectActionConfig = (input, context) => {
|
|
3343
3238
|
const entries = {};
|
|
3344
|
-
if (input.Protocol
|
|
3239
|
+
if (input.Protocol != null) {
|
|
3345
3240
|
entries["Protocol"] = input.Protocol;
|
|
3346
3241
|
}
|
|
3347
|
-
if (input.Port
|
|
3242
|
+
if (input.Port != null) {
|
|
3348
3243
|
entries["Port"] = input.Port;
|
|
3349
3244
|
}
|
|
3350
|
-
if (input.Host
|
|
3245
|
+
if (input.Host != null) {
|
|
3351
3246
|
entries["Host"] = input.Host;
|
|
3352
3247
|
}
|
|
3353
|
-
if (input.Path
|
|
3248
|
+
if (input.Path != null) {
|
|
3354
3249
|
entries["Path"] = input.Path;
|
|
3355
3250
|
}
|
|
3356
|
-
if (input.Query
|
|
3251
|
+
if (input.Query != null) {
|
|
3357
3252
|
entries["Query"] = input.Query;
|
|
3358
3253
|
}
|
|
3359
|
-
if (input.StatusCode
|
|
3254
|
+
if (input.StatusCode != null) {
|
|
3360
3255
|
entries["StatusCode"] = input.StatusCode;
|
|
3361
3256
|
}
|
|
3362
3257
|
return entries;
|
|
3363
3258
|
};
|
|
3364
3259
|
const serializeAws_queryRegisterTargetsInput = (input, context) => {
|
|
3365
3260
|
const entries = {};
|
|
3366
|
-
if (input.TargetGroupArn
|
|
3261
|
+
if (input.TargetGroupArn != null) {
|
|
3367
3262
|
entries["TargetGroupArn"] = input.TargetGroupArn;
|
|
3368
3263
|
}
|
|
3369
|
-
if (input.Targets
|
|
3264
|
+
if (input.Targets != null) {
|
|
3370
3265
|
const memberEntries = serializeAws_queryTargetDescriptions(input.Targets, context);
|
|
3371
3266
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3372
3267
|
const loc = `Targets.${key}`;
|
|
@@ -3377,10 +3272,10 @@ const serializeAws_queryRegisterTargetsInput = (input, context) => {
|
|
|
3377
3272
|
};
|
|
3378
3273
|
const serializeAws_queryRemoveListenerCertificatesInput = (input, context) => {
|
|
3379
3274
|
const entries = {};
|
|
3380
|
-
if (input.ListenerArn
|
|
3275
|
+
if (input.ListenerArn != null) {
|
|
3381
3276
|
entries["ListenerArn"] = input.ListenerArn;
|
|
3382
3277
|
}
|
|
3383
|
-
if (input.Certificates
|
|
3278
|
+
if (input.Certificates != null) {
|
|
3384
3279
|
const memberEntries = serializeAws_queryCertificateList(input.Certificates, context);
|
|
3385
3280
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3386
3281
|
const loc = `Certificates.${key}`;
|
|
@@ -3391,14 +3286,14 @@ const serializeAws_queryRemoveListenerCertificatesInput = (input, context) => {
|
|
|
3391
3286
|
};
|
|
3392
3287
|
const serializeAws_queryRemoveTagsInput = (input, context) => {
|
|
3393
3288
|
const entries = {};
|
|
3394
|
-
if (input.ResourceArns
|
|
3289
|
+
if (input.ResourceArns != null) {
|
|
3395
3290
|
const memberEntries = serializeAws_queryResourceArns(input.ResourceArns, context);
|
|
3396
3291
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3397
3292
|
const loc = `ResourceArns.${key}`;
|
|
3398
3293
|
entries[loc] = value;
|
|
3399
3294
|
});
|
|
3400
3295
|
}
|
|
3401
|
-
if (input.TagKeys
|
|
3296
|
+
if (input.TagKeys != null) {
|
|
3402
3297
|
const memberEntries = serializeAws_queryTagKeys(input.TagKeys, context);
|
|
3403
3298
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3404
3299
|
const loc = `TagKeys.${key}`;
|
|
@@ -3433,52 +3328,52 @@ const serializeAws_queryRuleArns = (input, context) => {
|
|
|
3433
3328
|
};
|
|
3434
3329
|
const serializeAws_queryRuleCondition = (input, context) => {
|
|
3435
3330
|
const entries = {};
|
|
3436
|
-
if (input.Field
|
|
3331
|
+
if (input.Field != null) {
|
|
3437
3332
|
entries["Field"] = input.Field;
|
|
3438
3333
|
}
|
|
3439
|
-
if (input.Values
|
|
3334
|
+
if (input.Values != null) {
|
|
3440
3335
|
const memberEntries = serializeAws_queryListOfString(input.Values, context);
|
|
3441
3336
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3442
3337
|
const loc = `Values.${key}`;
|
|
3443
3338
|
entries[loc] = value;
|
|
3444
3339
|
});
|
|
3445
3340
|
}
|
|
3446
|
-
if (input.HostHeaderConfig
|
|
3341
|
+
if (input.HostHeaderConfig != null) {
|
|
3447
3342
|
const memberEntries = serializeAws_queryHostHeaderConditionConfig(input.HostHeaderConfig, context);
|
|
3448
3343
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3449
3344
|
const loc = `HostHeaderConfig.${key}`;
|
|
3450
3345
|
entries[loc] = value;
|
|
3451
3346
|
});
|
|
3452
3347
|
}
|
|
3453
|
-
if (input.PathPatternConfig
|
|
3348
|
+
if (input.PathPatternConfig != null) {
|
|
3454
3349
|
const memberEntries = serializeAws_queryPathPatternConditionConfig(input.PathPatternConfig, context);
|
|
3455
3350
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3456
3351
|
const loc = `PathPatternConfig.${key}`;
|
|
3457
3352
|
entries[loc] = value;
|
|
3458
3353
|
});
|
|
3459
3354
|
}
|
|
3460
|
-
if (input.HttpHeaderConfig
|
|
3355
|
+
if (input.HttpHeaderConfig != null) {
|
|
3461
3356
|
const memberEntries = serializeAws_queryHttpHeaderConditionConfig(input.HttpHeaderConfig, context);
|
|
3462
3357
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3463
3358
|
const loc = `HttpHeaderConfig.${key}`;
|
|
3464
3359
|
entries[loc] = value;
|
|
3465
3360
|
});
|
|
3466
3361
|
}
|
|
3467
|
-
if (input.QueryStringConfig
|
|
3362
|
+
if (input.QueryStringConfig != null) {
|
|
3468
3363
|
const memberEntries = serializeAws_queryQueryStringConditionConfig(input.QueryStringConfig, context);
|
|
3469
3364
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3470
3365
|
const loc = `QueryStringConfig.${key}`;
|
|
3471
3366
|
entries[loc] = value;
|
|
3472
3367
|
});
|
|
3473
3368
|
}
|
|
3474
|
-
if (input.HttpRequestMethodConfig
|
|
3369
|
+
if (input.HttpRequestMethodConfig != null) {
|
|
3475
3370
|
const memberEntries = serializeAws_queryHttpRequestMethodConditionConfig(input.HttpRequestMethodConfig, context);
|
|
3476
3371
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3477
3372
|
const loc = `HttpRequestMethodConfig.${key}`;
|
|
3478
3373
|
entries[loc] = value;
|
|
3479
3374
|
});
|
|
3480
3375
|
}
|
|
3481
|
-
if (input.SourceIpConfig
|
|
3376
|
+
if (input.SourceIpConfig != null) {
|
|
3482
3377
|
const memberEntries = serializeAws_querySourceIpConditionConfig(input.SourceIpConfig, context);
|
|
3483
3378
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3484
3379
|
const loc = `SourceIpConfig.${key}`;
|
|
@@ -3519,10 +3414,10 @@ const serializeAws_queryRulePriorityList = (input, context) => {
|
|
|
3519
3414
|
};
|
|
3520
3415
|
const serializeAws_queryRulePriorityPair = (input, context) => {
|
|
3521
3416
|
const entries = {};
|
|
3522
|
-
if (input.RuleArn
|
|
3417
|
+
if (input.RuleArn != null) {
|
|
3523
3418
|
entries["RuleArn"] = input.RuleArn;
|
|
3524
3419
|
}
|
|
3525
|
-
if (input.Priority
|
|
3420
|
+
if (input.Priority != null) {
|
|
3526
3421
|
entries["Priority"] = input.Priority;
|
|
3527
3422
|
}
|
|
3528
3423
|
return entries;
|
|
@@ -3541,17 +3436,17 @@ const serializeAws_querySecurityGroups = (input, context) => {
|
|
|
3541
3436
|
};
|
|
3542
3437
|
const serializeAws_querySetIpAddressTypeInput = (input, context) => {
|
|
3543
3438
|
const entries = {};
|
|
3544
|
-
if (input.LoadBalancerArn
|
|
3439
|
+
if (input.LoadBalancerArn != null) {
|
|
3545
3440
|
entries["LoadBalancerArn"] = input.LoadBalancerArn;
|
|
3546
3441
|
}
|
|
3547
|
-
if (input.IpAddressType
|
|
3442
|
+
if (input.IpAddressType != null) {
|
|
3548
3443
|
entries["IpAddressType"] = input.IpAddressType;
|
|
3549
3444
|
}
|
|
3550
3445
|
return entries;
|
|
3551
3446
|
};
|
|
3552
3447
|
const serializeAws_querySetRulePrioritiesInput = (input, context) => {
|
|
3553
3448
|
const entries = {};
|
|
3554
|
-
if (input.RulePriorities
|
|
3449
|
+
if (input.RulePriorities != null) {
|
|
3555
3450
|
const memberEntries = serializeAws_queryRulePriorityList(input.RulePriorities, context);
|
|
3556
3451
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3557
3452
|
const loc = `RulePriorities.${key}`;
|
|
@@ -3562,10 +3457,10 @@ const serializeAws_querySetRulePrioritiesInput = (input, context) => {
|
|
|
3562
3457
|
};
|
|
3563
3458
|
const serializeAws_querySetSecurityGroupsInput = (input, context) => {
|
|
3564
3459
|
const entries = {};
|
|
3565
|
-
if (input.LoadBalancerArn
|
|
3460
|
+
if (input.LoadBalancerArn != null) {
|
|
3566
3461
|
entries["LoadBalancerArn"] = input.LoadBalancerArn;
|
|
3567
3462
|
}
|
|
3568
|
-
if (input.SecurityGroups
|
|
3463
|
+
if (input.SecurityGroups != null) {
|
|
3569
3464
|
const memberEntries = serializeAws_querySecurityGroups(input.SecurityGroups, context);
|
|
3570
3465
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3571
3466
|
const loc = `SecurityGroups.${key}`;
|
|
@@ -3576,31 +3471,31 @@ const serializeAws_querySetSecurityGroupsInput = (input, context) => {
|
|
|
3576
3471
|
};
|
|
3577
3472
|
const serializeAws_querySetSubnetsInput = (input, context) => {
|
|
3578
3473
|
const entries = {};
|
|
3579
|
-
if (input.LoadBalancerArn
|
|
3474
|
+
if (input.LoadBalancerArn != null) {
|
|
3580
3475
|
entries["LoadBalancerArn"] = input.LoadBalancerArn;
|
|
3581
3476
|
}
|
|
3582
|
-
if (input.Subnets
|
|
3477
|
+
if (input.Subnets != null) {
|
|
3583
3478
|
const memberEntries = serializeAws_querySubnets(input.Subnets, context);
|
|
3584
3479
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3585
3480
|
const loc = `Subnets.${key}`;
|
|
3586
3481
|
entries[loc] = value;
|
|
3587
3482
|
});
|
|
3588
3483
|
}
|
|
3589
|
-
if (input.SubnetMappings
|
|
3484
|
+
if (input.SubnetMappings != null) {
|
|
3590
3485
|
const memberEntries = serializeAws_querySubnetMappings(input.SubnetMappings, context);
|
|
3591
3486
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3592
3487
|
const loc = `SubnetMappings.${key}`;
|
|
3593
3488
|
entries[loc] = value;
|
|
3594
3489
|
});
|
|
3595
3490
|
}
|
|
3596
|
-
if (input.IpAddressType
|
|
3491
|
+
if (input.IpAddressType != null) {
|
|
3597
3492
|
entries["IpAddressType"] = input.IpAddressType;
|
|
3598
3493
|
}
|
|
3599
3494
|
return entries;
|
|
3600
3495
|
};
|
|
3601
3496
|
const serializeAws_querySourceIpConditionConfig = (input, context) => {
|
|
3602
3497
|
const entries = {};
|
|
3603
|
-
if (input.Values
|
|
3498
|
+
if (input.Values != null) {
|
|
3604
3499
|
const memberEntries = serializeAws_queryListOfString(input.Values, context);
|
|
3605
3500
|
Object.entries(memberEntries).forEach(([key, value]) => {
|
|
3606
3501
|
const loc = `Values.${key}`;
|
|
@@ -3623,16 +3518,16 @@ const serializeAws_querySslPolicyNames = (input, context) => {
|
|
|
3623
3518
|
};
|
|
3624
3519
|
const serializeAws_querySubnetMapping = (input, context) => {
|
|
3625
3520
|
const entries = {};
|
|
3626
|
-
if (input.SubnetId
|
|
3521
|
+
if (input.SubnetId != null) {
|
|
3627
3522
|
entries["SubnetId"] = input.SubnetId;
|
|
3628
3523
|
}
|
|
3629
|
-
if (input.AllocationId
|
|
3524
|
+
if (input.AllocationId != null) {
|
|
3630
3525
|
entries["AllocationId"] = input.AllocationId;
|
|
3631
3526
|
}
|
|
3632
|
-
if (input.PrivateIPv4Address
|
|
3527
|
+
if (input.PrivateIPv4Address != null) {
|
|
3633
3528
|
entries["PrivateIPv4Address"] = input.PrivateIPv4Address;
|
|
3634
3529
|
}
|
|
3635
|
-
if (input.IPv6Address
|
|
3530
|
+
if (input.IPv6Address != null) {
|
|
3636
3531
|
entries["IPv6Address"] = input.IPv6Address;
|
|
3637
3532
|
}
|
|
3638
3533
|
return entries;
|
|
@@ -3666,10 +3561,10 @@ const serializeAws_querySubnets = (input, context) => {
|
|
|
3666
3561
|
};
|
|
3667
3562
|
const serializeAws_queryTag = (input, context) => {
|
|
3668
3563
|
const entries = {};
|
|
3669
|
-
if (input.Key
|
|
3564
|
+
if (input.Key != null) {
|
|
3670
3565
|
entries["Key"] = input.Key;
|
|
3671
3566
|
}
|
|
3672
|
-
if (input.Value
|
|
3567
|
+
if (input.Value != null) {
|
|
3673
3568
|
entries["Value"] = input.Value;
|
|
3674
3569
|
}
|
|
3675
3570
|
return entries;
|
|
@@ -3703,13 +3598,13 @@ const serializeAws_queryTagList = (input, context) => {
|
|
|
3703
3598
|
};
|
|
3704
3599
|
const serializeAws_queryTargetDescription = (input, context) => {
|
|
3705
3600
|
const entries = {};
|
|
3706
|
-
if (input.Id
|
|
3601
|
+
if (input.Id != null) {
|
|
3707
3602
|
entries["Id"] = input.Id;
|
|
3708
3603
|
}
|
|
3709
|
-
if (input.Port
|
|
3604
|
+
if (input.Port != null) {
|
|
3710
3605
|
entries["Port"] = input.Port;
|
|
3711
3606
|
}
|
|
3712
|
-
if (input.AvailabilityZone
|
|
3607
|
+
if (input.AvailabilityZone != null) {
|
|
3713
3608
|
entries["AvailabilityZone"] = input.AvailabilityZone;
|
|
3714
3609
|
}
|
|
3715
3610
|
return entries;
|
|
@@ -3743,10 +3638,10 @@ const serializeAws_queryTargetGroupArns = (input, context) => {
|
|
|
3743
3638
|
};
|
|
3744
3639
|
const serializeAws_queryTargetGroupAttribute = (input, context) => {
|
|
3745
3640
|
const entries = {};
|
|
3746
|
-
if (input.Key
|
|
3641
|
+
if (input.Key != null) {
|
|
3747
3642
|
entries["Key"] = input.Key;
|
|
3748
3643
|
}
|
|
3749
|
-
if (input.Value
|
|
3644
|
+
if (input.Value != null) {
|
|
3750
3645
|
entries["Value"] = input.Value;
|
|
3751
3646
|
}
|
|
3752
3647
|
return entries;
|
|
@@ -3795,20 +3690,20 @@ const serializeAws_queryTargetGroupNames = (input, context) => {
|
|
|
3795
3690
|
};
|
|
3796
3691
|
const serializeAws_queryTargetGroupStickinessConfig = (input, context) => {
|
|
3797
3692
|
const entries = {};
|
|
3798
|
-
if (input.Enabled
|
|
3693
|
+
if (input.Enabled != null) {
|
|
3799
3694
|
entries["Enabled"] = input.Enabled;
|
|
3800
3695
|
}
|
|
3801
|
-
if (input.DurationSeconds
|
|
3696
|
+
if (input.DurationSeconds != null) {
|
|
3802
3697
|
entries["DurationSeconds"] = input.DurationSeconds;
|
|
3803
3698
|
}
|
|
3804
3699
|
return entries;
|
|
3805
3700
|
};
|
|
3806
3701
|
const serializeAws_queryTargetGroupTuple = (input, context) => {
|
|
3807
3702
|
const entries = {};
|
|
3808
|
-
if (input.TargetGroupArn
|
|
3703
|
+
if (input.TargetGroupArn != null) {
|
|
3809
3704
|
entries["TargetGroupArn"] = input.TargetGroupArn;
|
|
3810
3705
|
}
|
|
3811
|
-
if (input.Weight
|
|
3706
|
+
if (input.Weight != null) {
|
|
3812
3707
|
entries["Weight"] = input.Weight;
|
|
3813
3708
|
}
|
|
3814
3709
|
return entries;
|
|
@@ -3854,9 +3749,6 @@ const deserializeAws_queryActions = (output, context) => {
|
|
|
3854
3749
|
return (output || [])
|
|
3855
3750
|
.filter((e) => e != null)
|
|
3856
3751
|
.map((entry) => {
|
|
3857
|
-
if (entry === null) {
|
|
3858
|
-
return null;
|
|
3859
|
-
}
|
|
3860
3752
|
return deserializeAws_queryAction(entry, context);
|
|
3861
3753
|
});
|
|
3862
3754
|
};
|
|
@@ -3889,9 +3781,6 @@ const deserializeAws_queryAlpnPolicyName = (output, context) => {
|
|
|
3889
3781
|
return (output || [])
|
|
3890
3782
|
.filter((e) => e != null)
|
|
3891
3783
|
.map((entry) => {
|
|
3892
|
-
if (entry === null) {
|
|
3893
|
-
return null;
|
|
3894
|
-
}
|
|
3895
3784
|
return (0, smithy_client_1.expectString)(entry);
|
|
3896
3785
|
});
|
|
3897
3786
|
};
|
|
@@ -4063,9 +3952,6 @@ const deserializeAws_queryAvailabilityZones = (output, context) => {
|
|
|
4063
3952
|
return (output || [])
|
|
4064
3953
|
.filter((e) => e != null)
|
|
4065
3954
|
.map((entry) => {
|
|
4066
|
-
if (entry === null) {
|
|
4067
|
-
return null;
|
|
4068
|
-
}
|
|
4069
3955
|
return deserializeAws_queryAvailabilityZone(entry, context);
|
|
4070
3956
|
});
|
|
4071
3957
|
};
|
|
@@ -4086,9 +3972,6 @@ const deserializeAws_queryCertificateList = (output, context) => {
|
|
|
4086
3972
|
return (output || [])
|
|
4087
3973
|
.filter((e) => e != null)
|
|
4088
3974
|
.map((entry) => {
|
|
4089
|
-
if (entry === null) {
|
|
4090
|
-
return null;
|
|
4091
|
-
}
|
|
4092
3975
|
return deserializeAws_queryCertificate(entry, context);
|
|
4093
3976
|
});
|
|
4094
3977
|
};
|
|
@@ -4118,9 +4001,6 @@ const deserializeAws_queryCiphers = (output, context) => {
|
|
|
4118
4001
|
return (output || [])
|
|
4119
4002
|
.filter((e) => e != null)
|
|
4120
4003
|
.map((entry) => {
|
|
4121
|
-
if (entry === null) {
|
|
4122
|
-
return null;
|
|
4123
|
-
}
|
|
4124
4004
|
return deserializeAws_queryCipher(entry, context);
|
|
4125
4005
|
});
|
|
4126
4006
|
};
|
|
@@ -4551,9 +4431,6 @@ const deserializeAws_queryLimits = (output, context) => {
|
|
|
4551
4431
|
return (output || [])
|
|
4552
4432
|
.filter((e) => e != null)
|
|
4553
4433
|
.map((entry) => {
|
|
4554
|
-
if (entry === null) {
|
|
4555
|
-
return null;
|
|
4556
|
-
}
|
|
4557
4434
|
return deserializeAws_queryLimit(entry, context);
|
|
4558
4435
|
});
|
|
4559
4436
|
};
|
|
@@ -4616,9 +4493,6 @@ const deserializeAws_queryListeners = (output, context) => {
|
|
|
4616
4493
|
return (output || [])
|
|
4617
4494
|
.filter((e) => e != null)
|
|
4618
4495
|
.map((entry) => {
|
|
4619
|
-
if (entry === null) {
|
|
4620
|
-
return null;
|
|
4621
|
-
}
|
|
4622
4496
|
return deserializeAws_queryListener(entry, context);
|
|
4623
4497
|
});
|
|
4624
4498
|
};
|
|
@@ -4626,9 +4500,6 @@ const deserializeAws_queryListOfString = (output, context) => {
|
|
|
4626
4500
|
return (output || [])
|
|
4627
4501
|
.filter((e) => e != null)
|
|
4628
4502
|
.map((entry) => {
|
|
4629
|
-
if (entry === null) {
|
|
4630
|
-
return null;
|
|
4631
|
-
}
|
|
4632
4503
|
return (0, smithy_client_1.expectString)(entry);
|
|
4633
4504
|
});
|
|
4634
4505
|
};
|
|
@@ -4720,9 +4591,6 @@ const deserializeAws_queryLoadBalancerAddresses = (output, context) => {
|
|
|
4720
4591
|
return (output || [])
|
|
4721
4592
|
.filter((e) => e != null)
|
|
4722
4593
|
.map((entry) => {
|
|
4723
|
-
if (entry === null) {
|
|
4724
|
-
return null;
|
|
4725
|
-
}
|
|
4726
4594
|
return deserializeAws_queryLoadBalancerAddress(entry, context);
|
|
4727
4595
|
});
|
|
4728
4596
|
};
|
|
@@ -4730,9 +4598,6 @@ const deserializeAws_queryLoadBalancerArns = (output, context) => {
|
|
|
4730
4598
|
return (output || [])
|
|
4731
4599
|
.filter((e) => e != null)
|
|
4732
4600
|
.map((entry) => {
|
|
4733
|
-
if (entry === null) {
|
|
4734
|
-
return null;
|
|
4735
|
-
}
|
|
4736
4601
|
return (0, smithy_client_1.expectString)(entry);
|
|
4737
4602
|
});
|
|
4738
4603
|
};
|
|
@@ -4753,9 +4618,6 @@ const deserializeAws_queryLoadBalancerAttributes = (output, context) => {
|
|
|
4753
4618
|
return (output || [])
|
|
4754
4619
|
.filter((e) => e != null)
|
|
4755
4620
|
.map((entry) => {
|
|
4756
|
-
if (entry === null) {
|
|
4757
|
-
return null;
|
|
4758
|
-
}
|
|
4759
4621
|
return deserializeAws_queryLoadBalancerAttribute(entry, context);
|
|
4760
4622
|
});
|
|
4761
4623
|
};
|
|
@@ -4772,9 +4634,6 @@ const deserializeAws_queryLoadBalancers = (output, context) => {
|
|
|
4772
4634
|
return (output || [])
|
|
4773
4635
|
.filter((e) => e != null)
|
|
4774
4636
|
.map((entry) => {
|
|
4775
|
-
if (entry === null) {
|
|
4776
|
-
return null;
|
|
4777
|
-
}
|
|
4778
4637
|
return deserializeAws_queryLoadBalancer(entry, context);
|
|
4779
4638
|
});
|
|
4780
4639
|
};
|
|
@@ -4923,9 +4782,6 @@ const deserializeAws_queryQueryStringKeyValuePairList = (output, context) => {
|
|
|
4923
4782
|
return (output || [])
|
|
4924
4783
|
.filter((e) => e != null)
|
|
4925
4784
|
.map((entry) => {
|
|
4926
|
-
if (entry === null) {
|
|
4927
|
-
return null;
|
|
4928
|
-
}
|
|
4929
4785
|
return deserializeAws_queryQueryStringKeyValuePair(entry, context);
|
|
4930
4786
|
});
|
|
4931
4787
|
};
|
|
@@ -5054,9 +4910,6 @@ const deserializeAws_queryRuleConditionList = (output, context) => {
|
|
|
5054
4910
|
return (output || [])
|
|
5055
4911
|
.filter((e) => e != null)
|
|
5056
4912
|
.map((entry) => {
|
|
5057
|
-
if (entry === null) {
|
|
5058
|
-
return null;
|
|
5059
|
-
}
|
|
5060
4913
|
return deserializeAws_queryRuleCondition(entry, context);
|
|
5061
4914
|
});
|
|
5062
4915
|
};
|
|
@@ -5073,9 +4926,6 @@ const deserializeAws_queryRules = (output, context) => {
|
|
|
5073
4926
|
return (output || [])
|
|
5074
4927
|
.filter((e) => e != null)
|
|
5075
4928
|
.map((entry) => {
|
|
5076
|
-
if (entry === null) {
|
|
5077
|
-
return null;
|
|
5078
|
-
}
|
|
5079
4929
|
return deserializeAws_queryRule(entry, context);
|
|
5080
4930
|
});
|
|
5081
4931
|
};
|
|
@@ -5083,9 +4933,6 @@ const deserializeAws_querySecurityGroups = (output, context) => {
|
|
|
5083
4933
|
return (output || [])
|
|
5084
4934
|
.filter((e) => e != null)
|
|
5085
4935
|
.map((entry) => {
|
|
5086
|
-
if (entry === null) {
|
|
5087
|
-
return null;
|
|
5088
|
-
}
|
|
5089
4936
|
return (0, smithy_client_1.expectString)(entry);
|
|
5090
4937
|
});
|
|
5091
4938
|
};
|
|
@@ -5154,9 +5001,6 @@ const deserializeAws_querySslPolicies = (output, context) => {
|
|
|
5154
5001
|
return (output || [])
|
|
5155
5002
|
.filter((e) => e != null)
|
|
5156
5003
|
.map((entry) => {
|
|
5157
|
-
if (entry === null) {
|
|
5158
|
-
return null;
|
|
5159
|
-
}
|
|
5160
5004
|
return deserializeAws_querySslPolicy(entry, context);
|
|
5161
5005
|
});
|
|
5162
5006
|
};
|
|
@@ -5204,9 +5048,6 @@ const deserializeAws_querySslProtocols = (output, context) => {
|
|
|
5204
5048
|
return (output || [])
|
|
5205
5049
|
.filter((e) => e != null)
|
|
5206
5050
|
.map((entry) => {
|
|
5207
|
-
if (entry === null) {
|
|
5208
|
-
return null;
|
|
5209
|
-
}
|
|
5210
5051
|
return (0, smithy_client_1.expectString)(entry);
|
|
5211
5052
|
});
|
|
5212
5053
|
};
|
|
@@ -5252,9 +5093,6 @@ const deserializeAws_queryTagDescriptions = (output, context) => {
|
|
|
5252
5093
|
return (output || [])
|
|
5253
5094
|
.filter((e) => e != null)
|
|
5254
5095
|
.map((entry) => {
|
|
5255
|
-
if (entry === null) {
|
|
5256
|
-
return null;
|
|
5257
|
-
}
|
|
5258
5096
|
return deserializeAws_queryTagDescription(entry, context);
|
|
5259
5097
|
});
|
|
5260
5098
|
};
|
|
@@ -5262,9 +5100,6 @@ const deserializeAws_queryTagList = (output, context) => {
|
|
|
5262
5100
|
return (output || [])
|
|
5263
5101
|
.filter((e) => e != null)
|
|
5264
5102
|
.map((entry) => {
|
|
5265
|
-
if (entry === null) {
|
|
5266
|
-
return null;
|
|
5267
|
-
}
|
|
5268
5103
|
return deserializeAws_queryTag(entry, context);
|
|
5269
5104
|
});
|
|
5270
5105
|
};
|
|
@@ -5391,9 +5226,6 @@ const deserializeAws_queryTargetGroupAttributes = (output, context) => {
|
|
|
5391
5226
|
return (output || [])
|
|
5392
5227
|
.filter((e) => e != null)
|
|
5393
5228
|
.map((entry) => {
|
|
5394
|
-
if (entry === null) {
|
|
5395
|
-
return null;
|
|
5396
|
-
}
|
|
5397
5229
|
return deserializeAws_queryTargetGroupAttribute(entry, context);
|
|
5398
5230
|
});
|
|
5399
5231
|
};
|
|
@@ -5401,9 +5233,6 @@ const deserializeAws_queryTargetGroupList = (output, context) => {
|
|
|
5401
5233
|
return (output || [])
|
|
5402
5234
|
.filter((e) => e != null)
|
|
5403
5235
|
.map((entry) => {
|
|
5404
|
-
if (entry === null) {
|
|
5405
|
-
return null;
|
|
5406
|
-
}
|
|
5407
5236
|
return deserializeAws_queryTargetGroupTuple(entry, context);
|
|
5408
5237
|
});
|
|
5409
5238
|
};
|
|
@@ -5420,9 +5249,6 @@ const deserializeAws_queryTargetGroups = (output, context) => {
|
|
|
5420
5249
|
return (output || [])
|
|
5421
5250
|
.filter((e) => e != null)
|
|
5422
5251
|
.map((entry) => {
|
|
5423
|
-
if (entry === null) {
|
|
5424
|
-
return null;
|
|
5425
|
-
}
|
|
5426
5252
|
return deserializeAws_queryTargetGroup(entry, context);
|
|
5427
5253
|
});
|
|
5428
5254
|
};
|
|
@@ -5490,9 +5316,6 @@ const deserializeAws_queryTargetHealthDescriptions = (output, context) => {
|
|
|
5490
5316
|
return (output || [])
|
|
5491
5317
|
.filter((e) => e != null)
|
|
5492
5318
|
.map((entry) => {
|
|
5493
|
-
if (entry === null) {
|
|
5494
|
-
return null;
|
|
5495
|
-
}
|
|
5496
5319
|
return deserializeAws_queryTargetHealthDescription(entry, context);
|
|
5497
5320
|
});
|
|
5498
5321
|
};
|