@aws-sdk/client-elastic-load-balancing 3.137.0 → 3.145.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/CHANGELOG.md +30 -0
  2. package/README.md +1 -1
  3. package/dist-cjs/protocols/Aws_query.js +247 -397
  4. package/dist-es/protocols/Aws_query.js +331 -398
  5. package/package.json +11 -6
package/dist-cjs/protocols/Aws_query.js CHANGED
@@ -404,7 +404,6 @@ const deserializeAws_queryAddTagsCommandError = async (output, context) => {
404
404
  ...output,
405
405
  body: await parseBody(output.body, context),
406
406
  };
407
- let response;
408
407
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
409
408
  switch (errorCode) {
410
409
  case "AccessPointNotFoundException":
@@ -418,14 +417,12 @@ const deserializeAws_queryAddTagsCommandError = async (output, context) => {
418
417
  throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
419
418
  default:
420
419
  const parsedBody = parsedOutput.body;
421
- const $metadata = deserializeMetadata(output);
422
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
423
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
424
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
425
- $fault: "client",
426
- $metadata,
420
+ (0, smithy_client_1.throwDefaultError)({
421
+ output,
422
+ parsedBody: parsedBody.Error,
423
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
424
+ errorCode,
427
425
  });
428
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
429
426
  }
430
427
  };
431
428
  const deserializeAws_queryApplySecurityGroupsToLoadBalancerCommand = async (output, context) => {
@@ -447,7 +444,6 @@ const deserializeAws_queryApplySecurityGroupsToLoadBalancerCommandError = async
447
444
  ...output,
448
445
  body: await parseBody(output.body, context),
449
446
  };
450
- let response;
451
447
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
452
448
  switch (errorCode) {
453
449
  case "AccessPointNotFoundException":
@@ -461,14 +457,12 @@ const deserializeAws_queryApplySecurityGroupsToLoadBalancerCommandError = async
461
457
  throw await deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context);
462
458
  default:
463
459
  const parsedBody = parsedOutput.body;
464
- const $metadata = deserializeMetadata(output);
465
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
466
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
467
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
468
- $fault: "client",
469
- $metadata,
460
+ (0, smithy_client_1.throwDefaultError)({
461
+ output,
462
+ parsedBody: parsedBody.Error,
463
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
464
+ errorCode,
470
465
  });
471
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
472
466
  }
473
467
  };
474
468
  const deserializeAws_queryAttachLoadBalancerToSubnetsCommand = async (output, context) => {
@@ -490,7 +484,6 @@ const deserializeAws_queryAttachLoadBalancerToSubnetsCommandError = async (outpu
490
484
  ...output,
491
485
  body: await parseBody(output.body, context),
492
486
  };
493
- let response;
494
487
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
495
488
  switch (errorCode) {
496
489
  case "AccessPointNotFoundException":
@@ -507,14 +500,12 @@ const deserializeAws_queryAttachLoadBalancerToSubnetsCommandError = async (outpu
507
500
  throw await deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context);
508
501
  default:
509
502
  const parsedBody = parsedOutput.body;
510
- const $metadata = deserializeMetadata(output);
511
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
512
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
513
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
514
- $fault: "client",
515
- $metadata,
503
+ (0, smithy_client_1.throwDefaultError)({
504
+ output,
505
+ parsedBody: parsedBody.Error,
506
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
507
+ errorCode,
516
508
  });
517
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
518
509
  }
519
510
  };
520
511
  const deserializeAws_queryConfigureHealthCheckCommand = async (output, context) => {
@@ -536,7 +527,6 @@ const deserializeAws_queryConfigureHealthCheckCommandError = async (output, cont
536
527
  ...output,
537
528
  body: await parseBody(output.body, context),
538
529
  };
539
- let response;
540
530
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
541
531
  switch (errorCode) {
542
532
  case "AccessPointNotFoundException":
@@ -544,14 +534,12 @@ const deserializeAws_queryConfigureHealthCheckCommandError = async (output, cont
544
534
  throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
545
535
  default:
546
536
  const parsedBody = parsedOutput.body;
547
- const $metadata = deserializeMetadata(output);
548
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
549
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
550
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
551
- $fault: "client",
552
- $metadata,
537
+ (0, smithy_client_1.throwDefaultError)({
538
+ output,
539
+ parsedBody: parsedBody.Error,
540
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
541
+ errorCode,
553
542
  });
554
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
555
543
  }
556
544
  };
557
545
  const deserializeAws_queryCreateAppCookieStickinessPolicyCommand = async (output, context) => {
@@ -573,7 +561,6 @@ const deserializeAws_queryCreateAppCookieStickinessPolicyCommandError = async (o
573
561
  ...output,
574
562
  body: await parseBody(output.body, context),
575
563
  };
576
- let response;
577
564
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
578
565
  switch (errorCode) {
579
566
  case "AccessPointNotFoundException":
@@ -590,14 +577,12 @@ const deserializeAws_queryCreateAppCookieStickinessPolicyCommandError = async (o
590
577
  throw await deserializeAws_queryTooManyPoliciesExceptionResponse(parsedOutput, context);
591
578
  default:
592
579
  const parsedBody = parsedOutput.body;
593
- const $metadata = deserializeMetadata(output);
594
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
595
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
596
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
597
- $fault: "client",
598
- $metadata,
580
+ (0, smithy_client_1.throwDefaultError)({
581
+ output,
582
+ parsedBody: parsedBody.Error,
583
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
584
+ errorCode,
599
585
  });
600
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
601
586
  }
602
587
  };
603
588
  const deserializeAws_queryCreateLBCookieStickinessPolicyCommand = async (output, context) => {
@@ -619,7 +604,6 @@ const deserializeAws_queryCreateLBCookieStickinessPolicyCommandError = async (ou
619
604
  ...output,
620
605
  body: await parseBody(output.body, context),
621
606
  };
622
- let response;
623
607
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
624
608
  switch (errorCode) {
625
609
  case "AccessPointNotFoundException":
@@ -636,14 +620,12 @@ const deserializeAws_queryCreateLBCookieStickinessPolicyCommandError = async (ou
636
620
  throw await deserializeAws_queryTooManyPoliciesExceptionResponse(parsedOutput, context);
637
621
  default:
638
622
  const parsedBody = parsedOutput.body;
639
- const $metadata = deserializeMetadata(output);
640
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
641
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
642
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
643
- $fault: "client",
644
- $metadata,
623
+ (0, smithy_client_1.throwDefaultError)({
624
+ output,
625
+ parsedBody: parsedBody.Error,
626
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
627
+ errorCode,
645
628
  });
646
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
647
629
  }
648
630
  };
649
631
  const deserializeAws_queryCreateLoadBalancerCommand = async (output, context) => {
@@ -665,7 +647,6 @@ const deserializeAws_queryCreateLoadBalancerCommandError = async (output, contex
665
647
  ...output,
666
648
  body: await parseBody(output.body, context),
667
649
  };
668
- let response;
669
650
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
670
651
  switch (errorCode) {
671
652
  case "CertificateNotFoundException":
@@ -706,14 +687,12 @@ const deserializeAws_queryCreateLoadBalancerCommandError = async (output, contex
706
687
  throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
707
688
  default:
708
689
  const parsedBody = parsedOutput.body;
709
- const $metadata = deserializeMetadata(output);
710
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
711
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
712
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
713
- $fault: "client",
714
- $metadata,
690
+ (0, smithy_client_1.throwDefaultError)({
691
+ output,
692
+ parsedBody: parsedBody.Error,
693
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
694
+ errorCode,
715
695
  });
716
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
717
696
  }
718
697
  };
719
698
  const deserializeAws_queryCreateLoadBalancerListenersCommand = async (output, context) => {
@@ -735,7 +714,6 @@ const deserializeAws_queryCreateLoadBalancerListenersCommandError = async (outpu
735
714
  ...output,
736
715
  body: await parseBody(output.body, context),
737
716
  };
738
- let response;
739
717
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
740
718
  switch (errorCode) {
741
719
  case "AccessPointNotFoundException":
@@ -755,14 +733,12 @@ const deserializeAws_queryCreateLoadBalancerListenersCommandError = async (outpu
755
733
  throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
756
734
  default:
757
735
  const parsedBody = parsedOutput.body;
758
- const $metadata = deserializeMetadata(output);
759
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
760
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
761
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
762
- $fault: "client",
763
- $metadata,
736
+ (0, smithy_client_1.throwDefaultError)({
737
+ output,
738
+ parsedBody: parsedBody.Error,
739
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
740
+ errorCode,
764
741
  });
765
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
766
742
  }
767
743
  };
768
744
  const deserializeAws_queryCreateLoadBalancerPolicyCommand = async (output, context) => {
@@ -784,7 +760,6 @@ const deserializeAws_queryCreateLoadBalancerPolicyCommandError = async (output,
784
760
  ...output,
785
761
  body: await parseBody(output.body, context),
786
762
  };
787
- let response;
788
763
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
789
764
  switch (errorCode) {
790
765
  case "AccessPointNotFoundException":
@@ -804,14 +779,12 @@ const deserializeAws_queryCreateLoadBalancerPolicyCommandError = async (output,
804
779
  throw await deserializeAws_queryTooManyPoliciesExceptionResponse(parsedOutput, context);
805
780
  default:
806
781
  const parsedBody = parsedOutput.body;
807
- const $metadata = deserializeMetadata(output);
808
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
809
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
810
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
811
- $fault: "client",
812
- $metadata,
782
+ (0, smithy_client_1.throwDefaultError)({
783
+ output,
784
+ parsedBody: parsedBody.Error,
785
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
786
+ errorCode,
813
787
  });
814
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
815
788
  }
816
789
  };
817
790
  const deserializeAws_queryDeleteLoadBalancerCommand = async (output, context) => {
@@ -833,20 +806,14 @@ const deserializeAws_queryDeleteLoadBalancerCommandError = async (output, contex
833
806
  ...output,
834
807
  body: await parseBody(output.body, context),
835
808
  };
836
- let response;
837
809
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
838
- switch (errorCode) {
839
- default:
840
- const parsedBody = parsedOutput.body;
841
- const $metadata = deserializeMetadata(output);
842
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
843
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
844
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
845
- $fault: "client",
846
- $metadata,
847
- });
848
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
849
- }
810
+ const parsedBody = parsedOutput.body;
811
+ (0, smithy_client_1.throwDefaultError)({
812
+ output,
813
+ parsedBody: parsedBody.Error,
814
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
815
+ errorCode,
816
+ });
850
817
  };
851
818
  const deserializeAws_queryDeleteLoadBalancerListenersCommand = async (output, context) => {
852
819
  if (output.statusCode >= 300) {
@@ -867,7 +834,6 @@ const deserializeAws_queryDeleteLoadBalancerListenersCommandError = async (outpu
867
834
  ...output,
868
835
  body: await parseBody(output.body, context),
869
836
  };
870
- let response;
871
837
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
872
838
  switch (errorCode) {
873
839
  case "AccessPointNotFoundException":
@@ -875,14 +841,12 @@ const deserializeAws_queryDeleteLoadBalancerListenersCommandError = async (outpu
875
841
  throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
876
842
  default:
877
843
  const parsedBody = parsedOutput.body;
878
- const $metadata = deserializeMetadata(output);
879
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
880
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
881
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
882
- $fault: "client",
883
- $metadata,
844
+ (0, smithy_client_1.throwDefaultError)({
845
+ output,
846
+ parsedBody: parsedBody.Error,
847
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
848
+ errorCode,
884
849
  });
885
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
886
850
  }
887
851
  };
888
852
  const deserializeAws_queryDeleteLoadBalancerPolicyCommand = async (output, context) => {
@@ -904,7 +868,6 @@ const deserializeAws_queryDeleteLoadBalancerPolicyCommandError = async (output,
904
868
  ...output,
905
869
  body: await parseBody(output.body, context),
906
870
  };
907
- let response;
908
871
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
909
872
  switch (errorCode) {
910
873
  case "AccessPointNotFoundException":
@@ -915,14 +878,12 @@ const deserializeAws_queryDeleteLoadBalancerPolicyCommandError = async (output,
915
878
  throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
916
879
  default:
917
880
  const parsedBody = parsedOutput.body;
918
- const $metadata = deserializeMetadata(output);
919
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
920
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
921
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
922
- $fault: "client",
923
- $metadata,
881
+ (0, smithy_client_1.throwDefaultError)({
882
+ output,
883
+ parsedBody: parsedBody.Error,
884
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
885
+ errorCode,
924
886
  });
925
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
926
887
  }
927
888
  };
928
889
  const deserializeAws_queryDeregisterInstancesFromLoadBalancerCommand = async (output, context) => {
@@ -944,7 +905,6 @@ const deserializeAws_queryDeregisterInstancesFromLoadBalancerCommandError = asyn
944
905
  ...output,
945
906
  body: await parseBody(output.body, context),
946
907
  };
947
- let response;
948
908
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
949
909
  switch (errorCode) {
950
910
  case "AccessPointNotFoundException":
@@ -955,14 +915,12 @@ const deserializeAws_queryDeregisterInstancesFromLoadBalancerCommandError = asyn
955
915
  throw await deserializeAws_queryInvalidEndPointExceptionResponse(parsedOutput, context);
956
916
  default:
957
917
  const parsedBody = parsedOutput.body;
958
- const $metadata = deserializeMetadata(output);
959
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
960
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
961
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
962
- $fault: "client",
963
- $metadata,
918
+ (0, smithy_client_1.throwDefaultError)({
919
+ output,
920
+ parsedBody: parsedBody.Error,
921
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
922
+ errorCode,
964
923
  });
965
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
966
924
  }
967
925
  };
968
926
  const deserializeAws_queryDescribeAccountLimitsCommand = async (output, context) => {
@@ -984,20 +942,14 @@ const deserializeAws_queryDescribeAccountLimitsCommandError = async (output, con
984
942
  ...output,
985
943
  body: await parseBody(output.body, context),
986
944
  };
987
- let response;
988
945
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
989
- switch (errorCode) {
990
- default:
991
- const parsedBody = parsedOutput.body;
992
- const $metadata = deserializeMetadata(output);
993
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
994
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
995
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
996
- $fault: "client",
997
- $metadata,
998
- });
999
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
1000
- }
946
+ const parsedBody = parsedOutput.body;
947
+ (0, smithy_client_1.throwDefaultError)({
948
+ output,
949
+ parsedBody: parsedBody.Error,
950
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
951
+ errorCode,
952
+ });
1001
953
  };
1002
954
  const deserializeAws_queryDescribeInstanceHealthCommand = async (output, context) => {
1003
955
  if (output.statusCode >= 300) {
@@ -1018,7 +970,6 @@ const deserializeAws_queryDescribeInstanceHealthCommandError = async (output, co
1018
970
  ...output,
1019
971
  body: await parseBody(output.body, context),
1020
972
  };
1021
- let response;
1022
973
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1023
974
  switch (errorCode) {
1024
975
  case "AccessPointNotFoundException":
@@ -1029,14 +980,12 @@ const deserializeAws_queryDescribeInstanceHealthCommandError = async (output, co
1029
980
  throw await deserializeAws_queryInvalidEndPointExceptionResponse(parsedOutput, context);
1030
981
  default:
1031
982
  const parsedBody = parsedOutput.body;
1032
- const $metadata = deserializeMetadata(output);
1033
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1034
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
1035
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
1036
- $fault: "client",
1037
- $metadata,
983
+ (0, smithy_client_1.throwDefaultError)({
984
+ output,
985
+ parsedBody: parsedBody.Error,
986
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
987
+ errorCode,
1038
988
  });
1039
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
1040
989
  }
1041
990
  };
1042
991
  const deserializeAws_queryDescribeLoadBalancerAttributesCommand = async (output, context) => {
@@ -1058,7 +1007,6 @@ const deserializeAws_queryDescribeLoadBalancerAttributesCommandError = async (ou
1058
1007
  ...output,
1059
1008
  body: await parseBody(output.body, context),
1060
1009
  };
1061
- let response;
1062
1010
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1063
1011
  switch (errorCode) {
1064
1012
  case "AccessPointNotFoundException":
@@ -1069,14 +1017,12 @@ const deserializeAws_queryDescribeLoadBalancerAttributesCommandError = async (ou
1069
1017
  throw await deserializeAws_queryLoadBalancerAttributeNotFoundExceptionResponse(parsedOutput, context);
1070
1018
  default:
1071
1019
  const parsedBody = parsedOutput.body;
1072
- const $metadata = deserializeMetadata(output);
1073
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1074
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
1075
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
1076
- $fault: "client",
1077
- $metadata,
1020
+ (0, smithy_client_1.throwDefaultError)({
1021
+ output,
1022
+ parsedBody: parsedBody.Error,
1023
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
1024
+ errorCode,
1078
1025
  });
1079
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
1080
1026
  }
1081
1027
  };
1082
1028
  const deserializeAws_queryDescribeLoadBalancerPoliciesCommand = async (output, context) => {
@@ -1098,7 +1044,6 @@ const deserializeAws_queryDescribeLoadBalancerPoliciesCommandError = async (outp
1098
1044
  ...output,
1099
1045
  body: await parseBody(output.body, context),
1100
1046
  };
1101
- let response;
1102
1047
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1103
1048
  switch (errorCode) {
1104
1049
  case "AccessPointNotFoundException":
@@ -1109,14 +1054,12 @@ const deserializeAws_queryDescribeLoadBalancerPoliciesCommandError = async (outp
1109
1054
  throw await deserializeAws_queryPolicyNotFoundExceptionResponse(parsedOutput, context);
1110
1055
  default:
1111
1056
  const parsedBody = parsedOutput.body;
1112
- const $metadata = deserializeMetadata(output);
1113
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1114
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
1115
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
1116
- $fault: "client",
1117
- $metadata,
1057
+ (0, smithy_client_1.throwDefaultError)({
1058
+ output,
1059
+ parsedBody: parsedBody.Error,
1060
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
1061
+ errorCode,
1118
1062
  });
1119
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
1120
1063
  }
1121
1064
  };
1122
1065
  const deserializeAws_queryDescribeLoadBalancerPolicyTypesCommand = async (output, context) => {
@@ -1138,7 +1081,6 @@ const deserializeAws_queryDescribeLoadBalancerPolicyTypesCommandError = async (o
1138
1081
  ...output,
1139
1082
  body: await parseBody(output.body, context),
1140
1083
  };
1141
- let response;
1142
1084
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1143
1085
  switch (errorCode) {
1144
1086
  case "PolicyTypeNotFoundException":
@@ -1146,14 +1088,12 @@ const deserializeAws_queryDescribeLoadBalancerPolicyTypesCommandError = async (o
1146
1088
  throw await deserializeAws_queryPolicyTypeNotFoundExceptionResponse(parsedOutput, context);
1147
1089
  default:
1148
1090
  const parsedBody = parsedOutput.body;
1149
- const $metadata = deserializeMetadata(output);
1150
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1151
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
1152
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
1153
- $fault: "client",
1154
- $metadata,
1091
+ (0, smithy_client_1.throwDefaultError)({
1092
+ output,
1093
+ parsedBody: parsedBody.Error,
1094
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
1095
+ errorCode,
1155
1096
  });
1156
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
1157
1097
  }
1158
1098
  };
1159
1099
  const deserializeAws_queryDescribeLoadBalancersCommand = async (output, context) => {
@@ -1175,7 +1115,6 @@ const deserializeAws_queryDescribeLoadBalancersCommandError = async (output, con
1175
1115
  ...output,
1176
1116
  body: await parseBody(output.body, context),
1177
1117
  };
1178
- let response;
1179
1118
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1180
1119
  switch (errorCode) {
1181
1120
  case "AccessPointNotFoundException":
@@ -1186,14 +1125,12 @@ const deserializeAws_queryDescribeLoadBalancersCommandError = async (output, con
1186
1125
  throw await deserializeAws_queryDependencyThrottleExceptionResponse(parsedOutput, context);
1187
1126
  default:
1188
1127
  const parsedBody = parsedOutput.body;
1189
- const $metadata = deserializeMetadata(output);
1190
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1191
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
1192
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
1193
- $fault: "client",
1194
- $metadata,
1128
+ (0, smithy_client_1.throwDefaultError)({
1129
+ output,
1130
+ parsedBody: parsedBody.Error,
1131
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
1132
+ errorCode,
1195
1133
  });
1196
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
1197
1134
  }
1198
1135
  };
1199
1136
  const deserializeAws_queryDescribeTagsCommand = async (output, context) => {
@@ -1215,7 +1152,6 @@ const deserializeAws_queryDescribeTagsCommandError = async (output, context) =>
1215
1152
  ...output,
1216
1153
  body: await parseBody(output.body, context),
1217
1154
  };
1218
- let response;
1219
1155
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1220
1156
  switch (errorCode) {
1221
1157
  case "AccessPointNotFoundException":
@@ -1223,14 +1159,12 @@ const deserializeAws_queryDescribeTagsCommandError = async (output, context) =>
1223
1159
  throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
1224
1160
  default:
1225
1161
  const parsedBody = parsedOutput.body;
1226
- const $metadata = deserializeMetadata(output);
1227
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1228
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
1229
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
1230
- $fault: "client",
1231
- $metadata,
1162
+ (0, smithy_client_1.throwDefaultError)({
1163
+ output,
1164
+ parsedBody: parsedBody.Error,
1165
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
1166
+ errorCode,
1232
1167
  });
1233
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
1234
1168
  }
1235
1169
  };
1236
1170
  const deserializeAws_queryDetachLoadBalancerFromSubnetsCommand = async (output, context) => {
@@ -1252,7 +1186,6 @@ const deserializeAws_queryDetachLoadBalancerFromSubnetsCommandError = async (out
1252
1186
  ...output,
1253
1187
  body: await parseBody(output.body, context),
1254
1188
  };
1255
- let response;
1256
1189
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1257
1190
  switch (errorCode) {
1258
1191
  case "AccessPointNotFoundException":
@@ -1263,14 +1196,12 @@ const deserializeAws_queryDetachLoadBalancerFromSubnetsCommandError = async (out
1263
1196
  throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
1264
1197
  default:
1265
1198
  const parsedBody = parsedOutput.body;
1266
- const $metadata = deserializeMetadata(output);
1267
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1268
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
1269
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
1270
- $fault: "client",
1271
- $metadata,
1199
+ (0, smithy_client_1.throwDefaultError)({
1200
+ output,
1201
+ parsedBody: parsedBody.Error,
1202
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
1203
+ errorCode,
1272
1204
  });
1273
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
1274
1205
  }
1275
1206
  };
1276
1207
  const deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommand = async (output, context) => {
@@ -1292,7 +1223,6 @@ const deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommandError =
1292
1223
  ...output,
1293
1224
  body: await parseBody(output.body, context),
1294
1225
  };
1295
- let response;
1296
1226
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1297
1227
  switch (errorCode) {
1298
1228
  case "AccessPointNotFoundException":
@@ -1303,14 +1233,12 @@ const deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommandError =
1303
1233
  throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
1304
1234
  default:
1305
1235
  const parsedBody = parsedOutput.body;
1306
- const $metadata = deserializeMetadata(output);
1307
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1308
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
1309
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
1310
- $fault: "client",
1311
- $metadata,
1236
+ (0, smithy_client_1.throwDefaultError)({
1237
+ output,
1238
+ parsedBody: parsedBody.Error,
1239
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
1240
+ errorCode,
1312
1241
  });
1313
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
1314
1242
  }
1315
1243
  };
1316
1244
  const deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommand = async (output, context) => {
@@ -1332,7 +1260,6 @@ const deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommandError = a
1332
1260
  ...output,
1333
1261
  body: await parseBody(output.body, context),
1334
1262
  };
1335
- let response;
1336
1263
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1337
1264
  switch (errorCode) {
1338
1265
  case "AccessPointNotFoundException":
@@ -1340,14 +1267,12 @@ const deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommandError = a
1340
1267
  throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
1341
1268
  default:
1342
1269
  const parsedBody = parsedOutput.body;
1343
- const $metadata = deserializeMetadata(output);
1344
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1345
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
1346
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
1347
- $fault: "client",
1348
- $metadata,
1270
+ (0, smithy_client_1.throwDefaultError)({
1271
+ output,
1272
+ parsedBody: parsedBody.Error,
1273
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
1274
+ errorCode,
1349
1275
  });
1350
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
1351
1276
  }
1352
1277
  };
1353
1278
  const deserializeAws_queryModifyLoadBalancerAttributesCommand = async (output, context) => {
@@ -1369,7 +1294,6 @@ const deserializeAws_queryModifyLoadBalancerAttributesCommandError = async (outp
1369
1294
  ...output,
1370
1295
  body: await parseBody(output.body, context),
1371
1296
  };
1372
- let response;
1373
1297
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1374
1298
  switch (errorCode) {
1375
1299
  case "AccessPointNotFoundException":
@@ -1383,14 +1307,12 @@ const deserializeAws_queryModifyLoadBalancerAttributesCommandError = async (outp
1383
1307
  throw await deserializeAws_queryLoadBalancerAttributeNotFoundExceptionResponse(parsedOutput, context);
1384
1308
  default:
1385
1309
  const parsedBody = parsedOutput.body;
1386
- const $metadata = deserializeMetadata(output);
1387
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1388
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
1389
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
1390
- $fault: "client",
1391
- $metadata,
1310
+ (0, smithy_client_1.throwDefaultError)({
1311
+ output,
1312
+ parsedBody: parsedBody.Error,
1313
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
1314
+ errorCode,
1392
1315
  });
1393
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
1394
1316
  }
1395
1317
  };
1396
1318
  const deserializeAws_queryRegisterInstancesWithLoadBalancerCommand = async (output, context) => {
@@ -1412,7 +1334,6 @@ const deserializeAws_queryRegisterInstancesWithLoadBalancerCommandError = async
1412
1334
  ...output,
1413
1335
  body: await parseBody(output.body, context),
1414
1336
  };
1415
- let response;
1416
1337
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1417
1338
  switch (errorCode) {
1418
1339
  case "AccessPointNotFoundException":
@@ -1423,14 +1344,12 @@ const deserializeAws_queryRegisterInstancesWithLoadBalancerCommandError = async
1423
1344
  throw await deserializeAws_queryInvalidEndPointExceptionResponse(parsedOutput, context);
1424
1345
  default:
1425
1346
  const parsedBody = parsedOutput.body;
1426
- const $metadata = deserializeMetadata(output);
1427
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1428
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
1429
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
1430
- $fault: "client",
1431
- $metadata,
1347
+ (0, smithy_client_1.throwDefaultError)({
1348
+ output,
1349
+ parsedBody: parsedBody.Error,
1350
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
1351
+ errorCode,
1432
1352
  });
1433
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
1434
1353
  }
1435
1354
  };
1436
1355
  const deserializeAws_queryRemoveTagsCommand = async (output, context) => {
@@ -1452,7 +1371,6 @@ const deserializeAws_queryRemoveTagsCommandError = async (output, context) => {
1452
1371
  ...output,
1453
1372
  body: await parseBody(output.body, context),
1454
1373
  };
1455
- let response;
1456
1374
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1457
1375
  switch (errorCode) {
1458
1376
  case "AccessPointNotFoundException":
@@ -1460,14 +1378,12 @@ const deserializeAws_queryRemoveTagsCommandError = async (output, context) => {
1460
1378
  throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
1461
1379
  default:
1462
1380
  const parsedBody = parsedOutput.body;
1463
- const $metadata = deserializeMetadata(output);
1464
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1465
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
1466
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
1467
- $fault: "client",
1468
- $metadata,
1381
+ (0, smithy_client_1.throwDefaultError)({
1382
+ output,
1383
+ parsedBody: parsedBody.Error,
1384
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
1385
+ errorCode,
1469
1386
  });
1470
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
1471
1387
  }
1472
1388
  };
1473
1389
  const deserializeAws_querySetLoadBalancerListenerSSLCertificateCommand = async (output, context) => {
@@ -1489,7 +1405,6 @@ const deserializeAws_querySetLoadBalancerListenerSSLCertificateCommandError = as
1489
1405
  ...output,
1490
1406
  body: await parseBody(output.body, context),
1491
1407
  };
1492
- let response;
1493
1408
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1494
1409
  switch (errorCode) {
1495
1410
  case "AccessPointNotFoundException":
@@ -1509,14 +1424,12 @@ const deserializeAws_querySetLoadBalancerListenerSSLCertificateCommandError = as
1509
1424
  throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
1510
1425
  default:
1511
1426
  const parsedBody = parsedOutput.body;
1512
- const $metadata = deserializeMetadata(output);
1513
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1514
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
1515
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
1516
- $fault: "client",
1517
- $metadata,
1427
+ (0, smithy_client_1.throwDefaultError)({
1428
+ output,
1429
+ parsedBody: parsedBody.Error,
1430
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
1431
+ errorCode,
1518
1432
  });
1519
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
1520
1433
  }
1521
1434
  };
1522
1435
  const deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommand = async (output, context) => {
@@ -1538,7 +1451,6 @@ const deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommandError =
1538
1451
  ...output,
1539
1452
  body: await parseBody(output.body, context),
1540
1453
  };
1541
- let response;
1542
1454
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1543
1455
  switch (errorCode) {
1544
1456
  case "AccessPointNotFoundException":
@@ -1552,14 +1464,12 @@ const deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommandError =
1552
1464
  throw await deserializeAws_queryPolicyNotFoundExceptionResponse(parsedOutput, context);
1553
1465
  default:
1554
1466
  const parsedBody = parsedOutput.body;
1555
- const $metadata = deserializeMetadata(output);
1556
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1557
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
1558
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
1559
- $fault: "client",
1560
- $metadata,
1467
+ (0, smithy_client_1.throwDefaultError)({
1468
+ output,
1469
+ parsedBody: parsedBody.Error,
1470
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
1471
+ errorCode,
1561
1472
  });
1562
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
1563
1473
  }
1564
1474
  };
1565
1475
  const deserializeAws_querySetLoadBalancerPoliciesOfListenerCommand = async (output, context) => {
@@ -1581,7 +1491,6 @@ const deserializeAws_querySetLoadBalancerPoliciesOfListenerCommandError = async
1581
1491
  ...output,
1582
1492
  body: await parseBody(output.body, context),
1583
1493
  };
1584
- let response;
1585
1494
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
1586
1495
  switch (errorCode) {
1587
1496
  case "AccessPointNotFoundException":
@@ -1598,14 +1507,12 @@ const deserializeAws_querySetLoadBalancerPoliciesOfListenerCommandError = async
1598
1507
  throw await deserializeAws_queryPolicyNotFoundExceptionResponse(parsedOutput, context);
1599
1508
  default:
1600
1509
  const parsedBody = parsedOutput.body;
1601
- const $metadata = deserializeMetadata(output);
1602
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1603
- response = new ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
1604
- name: parsedBody.Error.code || parsedBody.Error.Code || errorCode || statusCode || "UnknowError",
1605
- $fault: "client",
1606
- $metadata,
1510
+ (0, smithy_client_1.throwDefaultError)({
1511
+ output,
1512
+ parsedBody: parsedBody.Error,
1513
+ exceptionCtor: ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException,
1514
+ errorCode,
1607
1515
  });
1608
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody.Error);
1609
1516
  }
1610
1517
  };
1611
1518
  const deserializeAws_queryAccessPointNotFoundExceptionResponse = async (parsedOutput, context) => {
@@ -1808,26 +1715,26 @@ const deserializeAws_queryUnsupportedProtocolExceptionResponse = async (parsedOu
1808
1715
  };
1809
1716
  const serializeAws_queryAccessLog = (input, context) => {
1810
1717
  const entries = {};
1811
- if (input.Enabled !== undefined && input.Enabled !== null) {
1718
+ if (input.Enabled != null) {
1812
1719
  entries["Enabled"] = input.Enabled;
1813
1720
  }
1814
- if (input.S3BucketName !== undefined && input.S3BucketName !== null) {
1721
+ if (input.S3BucketName != null) {
1815
1722
  entries["S3BucketName"] = input.S3BucketName;
1816
1723
  }
1817
- if (input.EmitInterval !== undefined && input.EmitInterval !== null) {
1724
+ if (input.EmitInterval != null) {
1818
1725
  entries["EmitInterval"] = input.EmitInterval;
1819
1726
  }
1820
- if (input.S3BucketPrefix !== undefined && input.S3BucketPrefix !== null) {
1727
+ if (input.S3BucketPrefix != null) {
1821
1728
  entries["S3BucketPrefix"] = input.S3BucketPrefix;
1822
1729
  }
1823
1730
  return entries;
1824
1731
  };
1825
1732
  const serializeAws_queryAddAvailabilityZonesInput = (input, context) => {
1826
1733
  const entries = {};
1827
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
1734
+ if (input.LoadBalancerName != null) {
1828
1735
  entries["LoadBalancerName"] = input.LoadBalancerName;
1829
1736
  }
1830
- if (input.AvailabilityZones !== undefined && input.AvailabilityZones !== null) {
1737
+ if (input.AvailabilityZones != null) {
1831
1738
  const memberEntries = serializeAws_queryAvailabilityZones(input.AvailabilityZones, context);
1832
1739
  Object.entries(memberEntries).forEach(([key, value]) => {
1833
1740
  const loc = `AvailabilityZones.${key}`;
@@ -1838,10 +1745,10 @@ const serializeAws_queryAddAvailabilityZonesInput = (input, context) => {
1838
1745
  };
1839
1746
  const serializeAws_queryAdditionalAttribute = (input, context) => {
1840
1747
  const entries = {};
1841
- if (input.Key !== undefined && input.Key !== null) {
1748
+ if (input.Key != null) {
1842
1749
  entries["Key"] = input.Key;
1843
1750
  }
1844
- if (input.Value !== undefined && input.Value !== null) {
1751
+ if (input.Value != null) {
1845
1752
  entries["Value"] = input.Value;
1846
1753
  }
1847
1754
  return entries;
@@ -1863,14 +1770,14 @@ const serializeAws_queryAdditionalAttributes = (input, context) => {
1863
1770
  };
1864
1771
  const serializeAws_queryAddTagsInput = (input, context) => {
1865
1772
  const entries = {};
1866
- if (input.LoadBalancerNames !== undefined && input.LoadBalancerNames !== null) {
1773
+ if (input.LoadBalancerNames != null) {
1867
1774
  const memberEntries = serializeAws_queryLoadBalancerNames(input.LoadBalancerNames, context);
1868
1775
  Object.entries(memberEntries).forEach(([key, value]) => {
1869
1776
  const loc = `LoadBalancerNames.${key}`;
1870
1777
  entries[loc] = value;
1871
1778
  });
1872
1779
  }
1873
- if (input.Tags !== undefined && input.Tags !== null) {
1780
+ if (input.Tags != null) {
1874
1781
  const memberEntries = serializeAws_queryTagList(input.Tags, context);
1875
1782
  Object.entries(memberEntries).forEach(([key, value]) => {
1876
1783
  const loc = `Tags.${key}`;
@@ -1881,10 +1788,10 @@ const serializeAws_queryAddTagsInput = (input, context) => {
1881
1788
  };
1882
1789
  const serializeAws_queryApplySecurityGroupsToLoadBalancerInput = (input, context) => {
1883
1790
  const entries = {};
1884
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
1791
+ if (input.LoadBalancerName != null) {
1885
1792
  entries["LoadBalancerName"] = input.LoadBalancerName;
1886
1793
  }
1887
- if (input.SecurityGroups !== undefined && input.SecurityGroups !== null) {
1794
+ if (input.SecurityGroups != null) {
1888
1795
  const memberEntries = serializeAws_querySecurityGroups(input.SecurityGroups, context);
1889
1796
  Object.entries(memberEntries).forEach(([key, value]) => {
1890
1797
  const loc = `SecurityGroups.${key}`;
@@ -1895,10 +1802,10 @@ const serializeAws_queryApplySecurityGroupsToLoadBalancerInput = (input, context
1895
1802
  };
1896
1803
  const serializeAws_queryAttachLoadBalancerToSubnetsInput = (input, context) => {
1897
1804
  const entries = {};
1898
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
1805
+ if (input.LoadBalancerName != null) {
1899
1806
  entries["LoadBalancerName"] = input.LoadBalancerName;
1900
1807
  }
1901
- if (input.Subnets !== undefined && input.Subnets !== null) {
1808
+ if (input.Subnets != null) {
1902
1809
  const memberEntries = serializeAws_querySubnets(input.Subnets, context);
1903
1810
  Object.entries(memberEntries).forEach(([key, value]) => {
1904
1811
  const loc = `Subnets.${key}`;
@@ -1921,10 +1828,10 @@ const serializeAws_queryAvailabilityZones = (input, context) => {
1921
1828
  };
1922
1829
  const serializeAws_queryConfigureHealthCheckInput = (input, context) => {
1923
1830
  const entries = {};
1924
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
1831
+ if (input.LoadBalancerName != null) {
1925
1832
  entries["LoadBalancerName"] = input.LoadBalancerName;
1926
1833
  }
1927
- if (input.HealthCheck !== undefined && input.HealthCheck !== null) {
1834
+ if (input.HealthCheck != null) {
1928
1835
  const memberEntries = serializeAws_queryHealthCheck(input.HealthCheck, context);
1929
1836
  Object.entries(memberEntries).forEach(([key, value]) => {
1930
1837
  const loc = `HealthCheck.${key}`;
@@ -1935,58 +1842,58 @@ const serializeAws_queryConfigureHealthCheckInput = (input, context) => {
1935
1842
  };
1936
1843
  const serializeAws_queryConnectionDraining = (input, context) => {
1937
1844
  const entries = {};
1938
- if (input.Enabled !== undefined && input.Enabled !== null) {
1845
+ if (input.Enabled != null) {
1939
1846
  entries["Enabled"] = input.Enabled;
1940
1847
  }
1941
- if (input.Timeout !== undefined && input.Timeout !== null) {
1848
+ if (input.Timeout != null) {
1942
1849
  entries["Timeout"] = input.Timeout;
1943
1850
  }
1944
1851
  return entries;
1945
1852
  };
1946
1853
  const serializeAws_queryConnectionSettings = (input, context) => {
1947
1854
  const entries = {};
1948
- if (input.IdleTimeout !== undefined && input.IdleTimeout !== null) {
1855
+ if (input.IdleTimeout != null) {
1949
1856
  entries["IdleTimeout"] = input.IdleTimeout;
1950
1857
  }
1951
1858
  return entries;
1952
1859
  };
1953
1860
  const serializeAws_queryCreateAccessPointInput = (input, context) => {
1954
1861
  const entries = {};
1955
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
1862
+ if (input.LoadBalancerName != null) {
1956
1863
  entries["LoadBalancerName"] = input.LoadBalancerName;
1957
1864
  }
1958
- if (input.Listeners !== undefined && input.Listeners !== null) {
1865
+ if (input.Listeners != null) {
1959
1866
  const memberEntries = serializeAws_queryListeners(input.Listeners, context);
1960
1867
  Object.entries(memberEntries).forEach(([key, value]) => {
1961
1868
  const loc = `Listeners.${key}`;
1962
1869
  entries[loc] = value;
1963
1870
  });
1964
1871
  }
1965
- if (input.AvailabilityZones !== undefined && input.AvailabilityZones !== null) {
1872
+ if (input.AvailabilityZones != null) {
1966
1873
  const memberEntries = serializeAws_queryAvailabilityZones(input.AvailabilityZones, context);
1967
1874
  Object.entries(memberEntries).forEach(([key, value]) => {
1968
1875
  const loc = `AvailabilityZones.${key}`;
1969
1876
  entries[loc] = value;
1970
1877
  });
1971
1878
  }
1972
- if (input.Subnets !== undefined && input.Subnets !== null) {
1879
+ if (input.Subnets != null) {
1973
1880
  const memberEntries = serializeAws_querySubnets(input.Subnets, context);
1974
1881
  Object.entries(memberEntries).forEach(([key, value]) => {
1975
1882
  const loc = `Subnets.${key}`;
1976
1883
  entries[loc] = value;
1977
1884
  });
1978
1885
  }
1979
- if (input.SecurityGroups !== undefined && input.SecurityGroups !== null) {
1886
+ if (input.SecurityGroups != null) {
1980
1887
  const memberEntries = serializeAws_querySecurityGroups(input.SecurityGroups, context);
1981
1888
  Object.entries(memberEntries).forEach(([key, value]) => {
1982
1889
  const loc = `SecurityGroups.${key}`;
1983
1890
  entries[loc] = value;
1984
1891
  });
1985
1892
  }
1986
- if (input.Scheme !== undefined && input.Scheme !== null) {
1893
+ if (input.Scheme != null) {
1987
1894
  entries["Scheme"] = input.Scheme;
1988
1895
  }
1989
- if (input.Tags !== undefined && input.Tags !== null) {
1896
+ if (input.Tags != null) {
1990
1897
  const memberEntries = serializeAws_queryTagList(input.Tags, context);
1991
1898
  Object.entries(memberEntries).forEach(([key, value]) => {
1992
1899
  const loc = `Tags.${key}`;
@@ -1997,36 +1904,36 @@ const serializeAws_queryCreateAccessPointInput = (input, context) => {
1997
1904
  };
1998
1905
  const serializeAws_queryCreateAppCookieStickinessPolicyInput = (input, context) => {
1999
1906
  const entries = {};
2000
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
1907
+ if (input.LoadBalancerName != null) {
2001
1908
  entries["LoadBalancerName"] = input.LoadBalancerName;
2002
1909
  }
2003
- if (input.PolicyName !== undefined && input.PolicyName !== null) {
1910
+ if (input.PolicyName != null) {
2004
1911
  entries["PolicyName"] = input.PolicyName;
2005
1912
  }
2006
- if (input.CookieName !== undefined && input.CookieName !== null) {
1913
+ if (input.CookieName != null) {
2007
1914
  entries["CookieName"] = input.CookieName;
2008
1915
  }
2009
1916
  return entries;
2010
1917
  };
2011
1918
  const serializeAws_queryCreateLBCookieStickinessPolicyInput = (input, context) => {
2012
1919
  const entries = {};
2013
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
1920
+ if (input.LoadBalancerName != null) {
2014
1921
  entries["LoadBalancerName"] = input.LoadBalancerName;
2015
1922
  }
2016
- if (input.PolicyName !== undefined && input.PolicyName !== null) {
1923
+ if (input.PolicyName != null) {
2017
1924
  entries["PolicyName"] = input.PolicyName;
2018
1925
  }
2019
- if (input.CookieExpirationPeriod !== undefined && input.CookieExpirationPeriod !== null) {
1926
+ if (input.CookieExpirationPeriod != null) {
2020
1927
  entries["CookieExpirationPeriod"] = input.CookieExpirationPeriod;
2021
1928
  }
2022
1929
  return entries;
2023
1930
  };
2024
1931
  const serializeAws_queryCreateLoadBalancerListenerInput = (input, context) => {
2025
1932
  const entries = {};
2026
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
1933
+ if (input.LoadBalancerName != null) {
2027
1934
  entries["LoadBalancerName"] = input.LoadBalancerName;
2028
1935
  }
2029
- if (input.Listeners !== undefined && input.Listeners !== null) {
1936
+ if (input.Listeners != null) {
2030
1937
  const memberEntries = serializeAws_queryListeners(input.Listeners, context);
2031
1938
  Object.entries(memberEntries).forEach(([key, value]) => {
2032
1939
  const loc = `Listeners.${key}`;
@@ -2037,16 +1944,16 @@ const serializeAws_queryCreateLoadBalancerListenerInput = (input, context) => {
2037
1944
  };
2038
1945
  const serializeAws_queryCreateLoadBalancerPolicyInput = (input, context) => {
2039
1946
  const entries = {};
2040
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
1947
+ if (input.LoadBalancerName != null) {
2041
1948
  entries["LoadBalancerName"] = input.LoadBalancerName;
2042
1949
  }
2043
- if (input.PolicyName !== undefined && input.PolicyName !== null) {
1950
+ if (input.PolicyName != null) {
2044
1951
  entries["PolicyName"] = input.PolicyName;
2045
1952
  }
2046
- if (input.PolicyTypeName !== undefined && input.PolicyTypeName !== null) {
1953
+ if (input.PolicyTypeName != null) {
2047
1954
  entries["PolicyTypeName"] = input.PolicyTypeName;
2048
1955
  }
2049
- if (input.PolicyAttributes !== undefined && input.PolicyAttributes !== null) {
1956
+ if (input.PolicyAttributes != null) {
2050
1957
  const memberEntries = serializeAws_queryPolicyAttributes(input.PolicyAttributes, context);
2051
1958
  Object.entries(memberEntries).forEach(([key, value]) => {
2052
1959
  const loc = `PolicyAttributes.${key}`;
@@ -2057,24 +1964,24 @@ const serializeAws_queryCreateLoadBalancerPolicyInput = (input, context) => {
2057
1964
  };
2058
1965
  const serializeAws_queryCrossZoneLoadBalancing = (input, context) => {
2059
1966
  const entries = {};
2060
- if (input.Enabled !== undefined && input.Enabled !== null) {
1967
+ if (input.Enabled != null) {
2061
1968
  entries["Enabled"] = input.Enabled;
2062
1969
  }
2063
1970
  return entries;
2064
1971
  };
2065
1972
  const serializeAws_queryDeleteAccessPointInput = (input, context) => {
2066
1973
  const entries = {};
2067
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
1974
+ if (input.LoadBalancerName != null) {
2068
1975
  entries["LoadBalancerName"] = input.LoadBalancerName;
2069
1976
  }
2070
1977
  return entries;
2071
1978
  };
2072
1979
  const serializeAws_queryDeleteLoadBalancerListenerInput = (input, context) => {
2073
1980
  const entries = {};
2074
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
1981
+ if (input.LoadBalancerName != null) {
2075
1982
  entries["LoadBalancerName"] = input.LoadBalancerName;
2076
1983
  }
2077
- if (input.LoadBalancerPorts !== undefined && input.LoadBalancerPorts !== null) {
1984
+ if (input.LoadBalancerPorts != null) {
2078
1985
  const memberEntries = serializeAws_queryPorts(input.LoadBalancerPorts, context);
2079
1986
  Object.entries(memberEntries).forEach(([key, value]) => {
2080
1987
  const loc = `LoadBalancerPorts.${key}`;
@@ -2085,20 +1992,20 @@ const serializeAws_queryDeleteLoadBalancerListenerInput = (input, context) => {
2085
1992
  };
2086
1993
  const serializeAws_queryDeleteLoadBalancerPolicyInput = (input, context) => {
2087
1994
  const entries = {};
2088
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
1995
+ if (input.LoadBalancerName != null) {
2089
1996
  entries["LoadBalancerName"] = input.LoadBalancerName;
2090
1997
  }
2091
- if (input.PolicyName !== undefined && input.PolicyName !== null) {
1998
+ if (input.PolicyName != null) {
2092
1999
  entries["PolicyName"] = input.PolicyName;
2093
2000
  }
2094
2001
  return entries;
2095
2002
  };
2096
2003
  const serializeAws_queryDeregisterEndPointsInput = (input, context) => {
2097
2004
  const entries = {};
2098
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
2005
+ if (input.LoadBalancerName != null) {
2099
2006
  entries["LoadBalancerName"] = input.LoadBalancerName;
2100
2007
  }
2101
- if (input.Instances !== undefined && input.Instances !== null) {
2008
+ if (input.Instances != null) {
2102
2009
  const memberEntries = serializeAws_queryInstances(input.Instances, context);
2103
2010
  Object.entries(memberEntries).forEach(([key, value]) => {
2104
2011
  const loc = `Instances.${key}`;
@@ -2109,37 +2016,37 @@ const serializeAws_queryDeregisterEndPointsInput = (input, context) => {
2109
2016
  };
2110
2017
  const serializeAws_queryDescribeAccessPointsInput = (input, context) => {
2111
2018
  const entries = {};
2112
- if (input.LoadBalancerNames !== undefined && input.LoadBalancerNames !== null) {
2019
+ if (input.LoadBalancerNames != null) {
2113
2020
  const memberEntries = serializeAws_queryLoadBalancerNames(input.LoadBalancerNames, context);
2114
2021
  Object.entries(memberEntries).forEach(([key, value]) => {
2115
2022
  const loc = `LoadBalancerNames.${key}`;
2116
2023
  entries[loc] = value;
2117
2024
  });
2118
2025
  }
2119
- if (input.Marker !== undefined && input.Marker !== null) {
2026
+ if (input.Marker != null) {
2120
2027
  entries["Marker"] = input.Marker;
2121
2028
  }
2122
- if (input.PageSize !== undefined && input.PageSize !== null) {
2029
+ if (input.PageSize != null) {
2123
2030
  entries["PageSize"] = input.PageSize;
2124
2031
  }
2125
2032
  return entries;
2126
2033
  };
2127
2034
  const serializeAws_queryDescribeAccountLimitsInput = (input, context) => {
2128
2035
  const entries = {};
2129
- if (input.Marker !== undefined && input.Marker !== null) {
2036
+ if (input.Marker != null) {
2130
2037
  entries["Marker"] = input.Marker;
2131
2038
  }
2132
- if (input.PageSize !== undefined && input.PageSize !== null) {
2039
+ if (input.PageSize != null) {
2133
2040
  entries["PageSize"] = input.PageSize;
2134
2041
  }
2135
2042
  return entries;
2136
2043
  };
2137
2044
  const serializeAws_queryDescribeEndPointStateInput = (input, context) => {
2138
2045
  const entries = {};
2139
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
2046
+ if (input.LoadBalancerName != null) {
2140
2047
  entries["LoadBalancerName"] = input.LoadBalancerName;
2141
2048
  }
2142
- if (input.Instances !== undefined && input.Instances !== null) {
2049
+ if (input.Instances != null) {
2143
2050
  const memberEntries = serializeAws_queryInstances(input.Instances, context);
2144
2051
  Object.entries(memberEntries).forEach(([key, value]) => {
2145
2052
  const loc = `Instances.${key}`;
@@ -2150,17 +2057,17 @@ const serializeAws_queryDescribeEndPointStateInput = (input, context) => {
2150
2057
  };
2151
2058
  const serializeAws_queryDescribeLoadBalancerAttributesInput = (input, context) => {
2152
2059
  const entries = {};
2153
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
2060
+ if (input.LoadBalancerName != null) {
2154
2061
  entries["LoadBalancerName"] = input.LoadBalancerName;
2155
2062
  }
2156
2063
  return entries;
2157
2064
  };
2158
2065
  const serializeAws_queryDescribeLoadBalancerPoliciesInput = (input, context) => {
2159
2066
  const entries = {};
2160
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
2067
+ if (input.LoadBalancerName != null) {
2161
2068
  entries["LoadBalancerName"] = input.LoadBalancerName;
2162
2069
  }
2163
- if (input.PolicyNames !== undefined && input.PolicyNames !== null) {
2070
+ if (input.PolicyNames != null) {
2164
2071
  const memberEntries = serializeAws_queryPolicyNames(input.PolicyNames, context);
2165
2072
  Object.entries(memberEntries).forEach(([key, value]) => {
2166
2073
  const loc = `PolicyNames.${key}`;
@@ -2171,7 +2078,7 @@ const serializeAws_queryDescribeLoadBalancerPoliciesInput = (input, context) =>
2171
2078
  };
2172
2079
  const serializeAws_queryDescribeLoadBalancerPolicyTypesInput = (input, context) => {
2173
2080
  const entries = {};
2174
- if (input.PolicyTypeNames !== undefined && input.PolicyTypeNames !== null) {
2081
+ if (input.PolicyTypeNames != null) {
2175
2082
  const memberEntries = serializeAws_queryPolicyTypeNames(input.PolicyTypeNames, context);
2176
2083
  Object.entries(memberEntries).forEach(([key, value]) => {
2177
2084
  const loc = `PolicyTypeNames.${key}`;
@@ -2182,7 +2089,7 @@ const serializeAws_queryDescribeLoadBalancerPolicyTypesInput = (input, context)
2182
2089
  };
2183
2090
  const serializeAws_queryDescribeTagsInput = (input, context) => {
2184
2091
  const entries = {};
2185
- if (input.LoadBalancerNames !== undefined && input.LoadBalancerNames !== null) {
2092
+ if (input.LoadBalancerNames != null) {
2186
2093
  const memberEntries = serializeAws_queryLoadBalancerNamesMax20(input.LoadBalancerNames, context);
2187
2094
  Object.entries(memberEntries).forEach(([key, value]) => {
2188
2095
  const loc = `LoadBalancerNames.${key}`;
@@ -2193,10 +2100,10 @@ const serializeAws_queryDescribeTagsInput = (input, context) => {
2193
2100
  };
2194
2101
  const serializeAws_queryDetachLoadBalancerFromSubnetsInput = (input, context) => {
2195
2102
  const entries = {};
2196
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
2103
+ if (input.LoadBalancerName != null) {
2197
2104
  entries["LoadBalancerName"] = input.LoadBalancerName;
2198
2105
  }
2199
- if (input.Subnets !== undefined && input.Subnets !== null) {
2106
+ if (input.Subnets != null) {
2200
2107
  const memberEntries = serializeAws_querySubnets(input.Subnets, context);
2201
2108
  Object.entries(memberEntries).forEach(([key, value]) => {
2202
2109
  const loc = `Subnets.${key}`;
@@ -2207,26 +2114,26 @@ const serializeAws_queryDetachLoadBalancerFromSubnetsInput = (input, context) =>
2207
2114
  };
2208
2115
  const serializeAws_queryHealthCheck = (input, context) => {
2209
2116
  const entries = {};
2210
- if (input.Target !== undefined && input.Target !== null) {
2117
+ if (input.Target != null) {
2211
2118
  entries["Target"] = input.Target;
2212
2119
  }
2213
- if (input.Interval !== undefined && input.Interval !== null) {
2120
+ if (input.Interval != null) {
2214
2121
  entries["Interval"] = input.Interval;
2215
2122
  }
2216
- if (input.Timeout !== undefined && input.Timeout !== null) {
2123
+ if (input.Timeout != null) {
2217
2124
  entries["Timeout"] = input.Timeout;
2218
2125
  }
2219
- if (input.UnhealthyThreshold !== undefined && input.UnhealthyThreshold !== null) {
2126
+ if (input.UnhealthyThreshold != null) {
2220
2127
  entries["UnhealthyThreshold"] = input.UnhealthyThreshold;
2221
2128
  }
2222
- if (input.HealthyThreshold !== undefined && input.HealthyThreshold !== null) {
2129
+ if (input.HealthyThreshold != null) {
2223
2130
  entries["HealthyThreshold"] = input.HealthyThreshold;
2224
2131
  }
2225
2132
  return entries;
2226
2133
  };
2227
2134
  const serializeAws_queryInstance = (input, context) => {
2228
2135
  const entries = {};
2229
- if (input.InstanceId !== undefined && input.InstanceId !== null) {
2136
+ if (input.InstanceId != null) {
2230
2137
  entries["InstanceId"] = input.InstanceId;
2231
2138
  }
2232
2139
  return entries;
@@ -2248,19 +2155,19 @@ const serializeAws_queryInstances = (input, context) => {
2248
2155
  };
2249
2156
  const serializeAws_queryListener = (input, context) => {
2250
2157
  const entries = {};
2251
- if (input.Protocol !== undefined && input.Protocol !== null) {
2158
+ if (input.Protocol != null) {
2252
2159
  entries["Protocol"] = input.Protocol;
2253
2160
  }
2254
- if (input.LoadBalancerPort !== undefined && input.LoadBalancerPort !== null) {
2161
+ if (input.LoadBalancerPort != null) {
2255
2162
  entries["LoadBalancerPort"] = input.LoadBalancerPort;
2256
2163
  }
2257
- if (input.InstanceProtocol !== undefined && input.InstanceProtocol !== null) {
2164
+ if (input.InstanceProtocol != null) {
2258
2165
  entries["InstanceProtocol"] = input.InstanceProtocol;
2259
2166
  }
2260
- if (input.InstancePort !== undefined && input.InstancePort !== null) {
2167
+ if (input.InstancePort != null) {
2261
2168
  entries["InstancePort"] = input.InstancePort;
2262
2169
  }
2263
- if (input.SSLCertificateId !== undefined && input.SSLCertificateId !== null) {
2170
+ if (input.SSLCertificateId != null) {
2264
2171
  entries["SSLCertificateId"] = input.SSLCertificateId;
2265
2172
  }
2266
2173
  return entries;
@@ -2282,35 +2189,35 @@ const serializeAws_queryListeners = (input, context) => {
2282
2189
  };
2283
2190
  const serializeAws_queryLoadBalancerAttributes = (input, context) => {
2284
2191
  const entries = {};
2285
- if (input.CrossZoneLoadBalancing !== undefined && input.CrossZoneLoadBalancing !== null) {
2192
+ if (input.CrossZoneLoadBalancing != null) {
2286
2193
  const memberEntries = serializeAws_queryCrossZoneLoadBalancing(input.CrossZoneLoadBalancing, context);
2287
2194
  Object.entries(memberEntries).forEach(([key, value]) => {
2288
2195
  const loc = `CrossZoneLoadBalancing.${key}`;
2289
2196
  entries[loc] = value;
2290
2197
  });
2291
2198
  }
2292
- if (input.AccessLog !== undefined && input.AccessLog !== null) {
2199
+ if (input.AccessLog != null) {
2293
2200
  const memberEntries = serializeAws_queryAccessLog(input.AccessLog, context);
2294
2201
  Object.entries(memberEntries).forEach(([key, value]) => {
2295
2202
  const loc = `AccessLog.${key}`;
2296
2203
  entries[loc] = value;
2297
2204
  });
2298
2205
  }
2299
- if (input.ConnectionDraining !== undefined && input.ConnectionDraining !== null) {
2206
+ if (input.ConnectionDraining != null) {
2300
2207
  const memberEntries = serializeAws_queryConnectionDraining(input.ConnectionDraining, context);
2301
2208
  Object.entries(memberEntries).forEach(([key, value]) => {
2302
2209
  const loc = `ConnectionDraining.${key}`;
2303
2210
  entries[loc] = value;
2304
2211
  });
2305
2212
  }
2306
- if (input.ConnectionSettings !== undefined && input.ConnectionSettings !== null) {
2213
+ if (input.ConnectionSettings != null) {
2307
2214
  const memberEntries = serializeAws_queryConnectionSettings(input.ConnectionSettings, context);
2308
2215
  Object.entries(memberEntries).forEach(([key, value]) => {
2309
2216
  const loc = `ConnectionSettings.${key}`;
2310
2217
  entries[loc] = value;
2311
2218
  });
2312
2219
  }
2313
- if (input.AdditionalAttributes !== undefined && input.AdditionalAttributes !== null) {
2220
+ if (input.AdditionalAttributes != null) {
2314
2221
  const memberEntries = serializeAws_queryAdditionalAttributes(input.AdditionalAttributes, context);
2315
2222
  Object.entries(memberEntries).forEach(([key, value]) => {
2316
2223
  const loc = `AdditionalAttributes.${key}`;
@@ -2345,10 +2252,10 @@ const serializeAws_queryLoadBalancerNamesMax20 = (input, context) => {
2345
2252
  };
2346
2253
  const serializeAws_queryModifyLoadBalancerAttributesInput = (input, context) => {
2347
2254
  const entries = {};
2348
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
2255
+ if (input.LoadBalancerName != null) {
2349
2256
  entries["LoadBalancerName"] = input.LoadBalancerName;
2350
2257
  }
2351
- if (input.LoadBalancerAttributes !== undefined && input.LoadBalancerAttributes !== null) {
2258
+ if (input.LoadBalancerAttributes != null) {
2352
2259
  const memberEntries = serializeAws_queryLoadBalancerAttributes(input.LoadBalancerAttributes, context);
2353
2260
  Object.entries(memberEntries).forEach(([key, value]) => {
2354
2261
  const loc = `LoadBalancerAttributes.${key}`;
@@ -2359,10 +2266,10 @@ const serializeAws_queryModifyLoadBalancerAttributesInput = (input, context) =>
2359
2266
  };
2360
2267
  const serializeAws_queryPolicyAttribute = (input, context) => {
2361
2268
  const entries = {};
2362
- if (input.AttributeName !== undefined && input.AttributeName !== null) {
2269
+ if (input.AttributeName != null) {
2363
2270
  entries["AttributeName"] = input.AttributeName;
2364
2271
  }
2365
- if (input.AttributeValue !== undefined && input.AttributeValue !== null) {
2272
+ if (input.AttributeValue != null) {
2366
2273
  entries["AttributeValue"] = input.AttributeValue;
2367
2274
  }
2368
2275
  return entries;
@@ -2420,10 +2327,10 @@ const serializeAws_queryPorts = (input, context) => {
2420
2327
  };
2421
2328
  const serializeAws_queryRegisterEndPointsInput = (input, context) => {
2422
2329
  const entries = {};
2423
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
2330
+ if (input.LoadBalancerName != null) {
2424
2331
  entries["LoadBalancerName"] = input.LoadBalancerName;
2425
2332
  }
2426
- if (input.Instances !== undefined && input.Instances !== null) {
2333
+ if (input.Instances != null) {
2427
2334
  const memberEntries = serializeAws_queryInstances(input.Instances, context);
2428
2335
  Object.entries(memberEntries).forEach(([key, value]) => {
2429
2336
  const loc = `Instances.${key}`;
@@ -2434,10 +2341,10 @@ const serializeAws_queryRegisterEndPointsInput = (input, context) => {
2434
2341
  };
2435
2342
  const serializeAws_queryRemoveAvailabilityZonesInput = (input, context) => {
2436
2343
  const entries = {};
2437
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
2344
+ if (input.LoadBalancerName != null) {
2438
2345
  entries["LoadBalancerName"] = input.LoadBalancerName;
2439
2346
  }
2440
- if (input.AvailabilityZones !== undefined && input.AvailabilityZones !== null) {
2347
+ if (input.AvailabilityZones != null) {
2441
2348
  const memberEntries = serializeAws_queryAvailabilityZones(input.AvailabilityZones, context);
2442
2349
  Object.entries(memberEntries).forEach(([key, value]) => {
2443
2350
  const loc = `AvailabilityZones.${key}`;
@@ -2448,14 +2355,14 @@ const serializeAws_queryRemoveAvailabilityZonesInput = (input, context) => {
2448
2355
  };
2449
2356
  const serializeAws_queryRemoveTagsInput = (input, context) => {
2450
2357
  const entries = {};
2451
- if (input.LoadBalancerNames !== undefined && input.LoadBalancerNames !== null) {
2358
+ if (input.LoadBalancerNames != null) {
2452
2359
  const memberEntries = serializeAws_queryLoadBalancerNames(input.LoadBalancerNames, context);
2453
2360
  Object.entries(memberEntries).forEach(([key, value]) => {
2454
2361
  const loc = `LoadBalancerNames.${key}`;
2455
2362
  entries[loc] = value;
2456
2363
  });
2457
2364
  }
2458
- if (input.Tags !== undefined && input.Tags !== null) {
2365
+ if (input.Tags != null) {
2459
2366
  const memberEntries = serializeAws_queryTagKeyList(input.Tags, context);
2460
2367
  Object.entries(memberEntries).forEach(([key, value]) => {
2461
2368
  const loc = `Tags.${key}`;
@@ -2478,26 +2385,26 @@ const serializeAws_querySecurityGroups = (input, context) => {
2478
2385
  };
2479
2386
  const serializeAws_querySetLoadBalancerListenerSSLCertificateInput = (input, context) => {
2480
2387
  const entries = {};
2481
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
2388
+ if (input.LoadBalancerName != null) {
2482
2389
  entries["LoadBalancerName"] = input.LoadBalancerName;
2483
2390
  }
2484
- if (input.LoadBalancerPort !== undefined && input.LoadBalancerPort !== null) {
2391
+ if (input.LoadBalancerPort != null) {
2485
2392
  entries["LoadBalancerPort"] = input.LoadBalancerPort;
2486
2393
  }
2487
- if (input.SSLCertificateId !== undefined && input.SSLCertificateId !== null) {
2394
+ if (input.SSLCertificateId != null) {
2488
2395
  entries["SSLCertificateId"] = input.SSLCertificateId;
2489
2396
  }
2490
2397
  return entries;
2491
2398
  };
2492
2399
  const serializeAws_querySetLoadBalancerPoliciesForBackendServerInput = (input, context) => {
2493
2400
  const entries = {};
2494
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
2401
+ if (input.LoadBalancerName != null) {
2495
2402
  entries["LoadBalancerName"] = input.LoadBalancerName;
2496
2403
  }
2497
- if (input.InstancePort !== undefined && input.InstancePort !== null) {
2404
+ if (input.InstancePort != null) {
2498
2405
  entries["InstancePort"] = input.InstancePort;
2499
2406
  }
2500
- if (input.PolicyNames !== undefined && input.PolicyNames !== null) {
2407
+ if (input.PolicyNames != null) {
2501
2408
  const memberEntries = serializeAws_queryPolicyNames(input.PolicyNames, context);
2502
2409
  Object.entries(memberEntries).forEach(([key, value]) => {
2503
2410
  const loc = `PolicyNames.${key}`;
@@ -2508,13 +2415,13 @@ const serializeAws_querySetLoadBalancerPoliciesForBackendServerInput = (input, c
2508
2415
  };
2509
2416
  const serializeAws_querySetLoadBalancerPoliciesOfListenerInput = (input, context) => {
2510
2417
  const entries = {};
2511
- if (input.LoadBalancerName !== undefined && input.LoadBalancerName !== null) {
2418
+ if (input.LoadBalancerName != null) {
2512
2419
  entries["LoadBalancerName"] = input.LoadBalancerName;
2513
2420
  }
2514
- if (input.LoadBalancerPort !== undefined && input.LoadBalancerPort !== null) {
2421
+ if (input.LoadBalancerPort != null) {
2515
2422
  entries["LoadBalancerPort"] = input.LoadBalancerPort;
2516
2423
  }
2517
- if (input.PolicyNames !== undefined && input.PolicyNames !== null) {
2424
+ if (input.PolicyNames != null) {
2518
2425
  const memberEntries = serializeAws_queryPolicyNames(input.PolicyNames, context);
2519
2426
  Object.entries(memberEntries).forEach(([key, value]) => {
2520
2427
  const loc = `PolicyNames.${key}`;
@@ -2537,10 +2444,10 @@ const serializeAws_querySubnets = (input, context) => {
2537
2444
  };
2538
2445
  const serializeAws_queryTag = (input, context) => {
2539
2446
  const entries = {};
2540
- if (input.Key !== undefined && input.Key !== null) {
2447
+ if (input.Key != null) {
2541
2448
  entries["Key"] = input.Key;
2542
2449
  }
2543
- if (input.Value !== undefined && input.Value !== null) {
2450
+ if (input.Value != null) {
2544
2451
  entries["Value"] = input.Value;
2545
2452
  }
2546
2453
  return entries;
@@ -2562,7 +2469,7 @@ const serializeAws_queryTagKeyList = (input, context) => {
2562
2469
  };
2563
2470
  const serializeAws_queryTagKeyOnly = (input, context) => {
2564
2471
  const entries = {};
2565
- if (input.Key !== undefined && input.Key !== null) {
2472
+ if (input.Key != null) {
2566
2473
  entries["Key"] = input.Key;
2567
2474
  }
2568
2475
  return entries;
@@ -2641,9 +2548,6 @@ const deserializeAws_queryAdditionalAttributes = (output, context) => {
2641
2548
  return (output || [])
2642
2549
  .filter((e) => e != null)
2643
2550
  .map((entry) => {
2644
- if (entry === null) {
2645
- return null;
2646
- }
2647
2551
  return deserializeAws_queryAdditionalAttribute(entry, context);
2648
2552
  });
2649
2553
  };
@@ -2655,9 +2559,6 @@ const deserializeAws_queryAppCookieStickinessPolicies = (output, context) => {
2655
2559
  return (output || [])
2656
2560
  .filter((e) => e != null)
2657
2561
  .map((entry) => {
2658
- if (entry === null) {
2659
- return null;
2660
- }
2661
2562
  return deserializeAws_queryAppCookieStickinessPolicy(entry, context);
2662
2563
  });
2663
2564
  };
@@ -2702,9 +2603,6 @@ const deserializeAws_queryAvailabilityZones = (output, context) => {
2702
2603
  return (output || [])
2703
2604
  .filter((e) => e != null)
2704
2605
  .map((entry) => {
2705
- if (entry === null) {
2706
- return null;
2707
- }
2708
2606
  return (0, smithy_client_1.expectString)(entry);
2709
2607
  });
2710
2608
  };
@@ -2728,9 +2626,6 @@ const deserializeAws_queryBackendServerDescriptions = (output, context) => {
2728
2626
  return (output || [])
2729
2627
  .filter((e) => e != null)
2730
2628
  .map((entry) => {
2731
- if (entry === null) {
2732
- return null;
2733
- }
2734
2629
  return deserializeAws_queryBackendServerDescription(entry, context);
2735
2630
  });
2736
2631
  };
@@ -3018,9 +2913,6 @@ const deserializeAws_queryInstances = (output, context) => {
3018
2913
  return (output || [])
3019
2914
  .filter((e) => e != null)
3020
2915
  .map((entry) => {
3021
- if (entry === null) {
3022
- return null;
3023
- }
3024
2916
  return deserializeAws_queryInstance(entry, context);
3025
2917
  });
3026
2918
  };
@@ -3049,9 +2941,6 @@ const deserializeAws_queryInstanceStates = (output, context) => {
3049
2941
  return (output || [])
3050
2942
  .filter((e) => e != null)
3051
2943
  .map((entry) => {
3052
- if (entry === null) {
3053
- return null;
3054
- }
3055
2944
  return deserializeAws_queryInstanceState(entry, context);
3056
2945
  });
3057
2946
  };
@@ -3104,9 +2993,6 @@ const deserializeAws_queryLBCookieStickinessPolicies = (output, context) => {
3104
2993
  return (output || [])
3105
2994
  .filter((e) => e != null)
3106
2995
  .map((entry) => {
3107
- if (entry === null) {
3108
- return null;
3109
- }
3110
2996
  return deserializeAws_queryLBCookieStickinessPolicy(entry, context);
3111
2997
  });
3112
2998
  };
@@ -3140,9 +3026,6 @@ const deserializeAws_queryLimits = (output, context) => {
3140
3026
  return (output || [])
3141
3027
  .filter((e) => e != null)
3142
3028
  .map((entry) => {
3143
- if (entry === null) {
3144
- return null;
3145
- }
3146
3029
  return deserializeAws_queryLimit(entry, context);
3147
3030
  });
3148
3031
  };
@@ -3191,9 +3074,6 @@ const deserializeAws_queryListenerDescriptions = (output, context) => {
3191
3074
  return (output || [])
3192
3075
  .filter((e) => e != null)
3193
3076
  .map((entry) => {
3194
- if (entry === null) {
3195
- return null;
3196
- }
3197
3077
  return deserializeAws_queryListenerDescription(entry, context);
3198
3078
  });
3199
3079
  };
@@ -3335,9 +3215,6 @@ const deserializeAws_queryLoadBalancerDescriptions = (output, context) => {
3335
3215
  return (output || [])
3336
3216
  .filter((e) => e != null)
3337
3217
  .map((entry) => {
3338
- if (entry === null) {
3339
- return null;
3340
- }
3341
3218
  return deserializeAws_queryLoadBalancerDescription(entry, context);
3342
3219
  });
3343
3220
  };
@@ -3408,9 +3285,6 @@ const deserializeAws_queryPolicyAttributeDescriptions = (output, context) => {
3408
3285
  return (output || [])
3409
3286
  .filter((e) => e != null)
3410
3287
  .map((entry) => {
3411
- if (entry === null) {
3412
- return null;
3413
- }
3414
3288
  return deserializeAws_queryPolicyAttributeDescription(entry, context);
3415
3289
  });
3416
3290
  };
@@ -3443,9 +3317,6 @@ const deserializeAws_queryPolicyAttributeTypeDescriptions = (output, context) =>
3443
3317
  return (output || [])
3444
3318
  .filter((e) => e != null)
3445
3319
  .map((entry) => {
3446
- if (entry === null) {
3447
- return null;
3448
- }
3449
3320
  return deserializeAws_queryPolicyAttributeTypeDescription(entry, context);
3450
3321
  });
3451
3322
  };
@@ -3474,9 +3345,6 @@ const deserializeAws_queryPolicyDescriptions = (output, context) => {
3474
3345
  return (output || [])
3475
3346
  .filter((e) => e != null)
3476
3347
  .map((entry) => {
3477
- if (entry === null) {
3478
- return null;
3479
- }
3480
3348
  return deserializeAws_queryPolicyDescription(entry, context);
3481
3349
  });
3482
3350
  };
@@ -3484,9 +3352,6 @@ const deserializeAws_queryPolicyNames = (output, context) => {
3484
3352
  return (output || [])
3485
3353
  .filter((e) => e != null)
3486
3354
  .map((entry) => {
3487
- if (entry === null) {
3488
- return null;
3489
- }
3490
3355
  return (0, smithy_client_1.expectString)(entry);
3491
3356
  });
3492
3357
  };
@@ -3524,9 +3389,6 @@ const deserializeAws_queryPolicyTypeDescriptions = (output, context) => {
3524
3389
  return (output || [])
3525
3390
  .filter((e) => e != null)
3526
3391
  .map((entry) => {
3527
- if (entry === null) {
3528
- return null;
3529
- }
3530
3392
  return deserializeAws_queryPolicyTypeDescription(entry, context);
3531
3393
  });
3532
3394
  };
@@ -3571,9 +3433,6 @@ const deserializeAws_querySecurityGroups = (output, context) => {
3571
3433
  return (output || [])
3572
3434
  .filter((e) => e != null)
3573
3435
  .map((entry) => {
3574
- if (entry === null) {
3575
- return null;
3576
- }
3577
3436
  return (0, smithy_client_1.expectString)(entry);
3578
3437
  });
3579
3438
  };
@@ -3615,9 +3474,6 @@ const deserializeAws_querySubnets = (output, context) => {
3615
3474
  return (output || [])
3616
3475
  .filter((e) => e != null)
3617
3476
  .map((entry) => {
3618
- if (entry === null) {
3619
- return null;
3620
- }
3621
3477
  return (0, smithy_client_1.expectString)(entry);
3622
3478
  });
3623
3479
  };
@@ -3654,9 +3510,6 @@ const deserializeAws_queryTagDescriptions = (output, context) => {
3654
3510
  return (output || [])
3655
3511
  .filter((e) => e != null)
3656
3512
  .map((entry) => {
3657
- if (entry === null) {
3658
- return null;
3659
- }
3660
3513
  return deserializeAws_queryTagDescription(entry, context);
3661
3514
  });
3662
3515
  };
@@ -3664,9 +3517,6 @@ const deserializeAws_queryTagList = (output, context) => {
3664
3517
  return (output || [])
3665
3518
  .filter((e) => e != null)
3666
3519
  .map((entry) => {
3667
- if (entry === null) {
3668
- return null;
3669
- }
3670
3520
  return deserializeAws_queryTag(entry, context);
3671
3521
  });
3672
3522
  };