@aws-sdk/client-elastic-load-balancing 3.180.0 → 3.181.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +18 -0
- package/dist-cjs/protocols/Aws_query.js +154 -146
- package/dist-es/protocols/Aws_query.js +221 -206
- package/package.json +3 -3
|
@@ -321,23 +321,23 @@ var deserializeAws_queryAddTagsCommandError = function (output, context) { retur
|
|
|
321
321
|
case 0:
|
|
322
322
|
_a = [__assign({}, output)];
|
|
323
323
|
_c = {};
|
|
324
|
-
return [4,
|
|
324
|
+
return [4, parseErrorBody(output.body, context)];
|
|
325
325
|
case 1:
|
|
326
326
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
327
327
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
328
328
|
_b = errorCode;
|
|
329
329
|
switch (_b) {
|
|
330
|
-
case "
|
|
331
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
332
|
-
case "
|
|
333
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
334
|
-
case "
|
|
330
|
+
case "DuplicateTagKeys": return [3, 2];
|
|
331
|
+
case "com.amazonaws.elasticloadbalancing#DuplicateTagKeysException": return [3, 2];
|
|
332
|
+
case "LoadBalancerNotFound": return [3, 4];
|
|
333
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 4];
|
|
334
|
+
case "TooManyTags": return [3, 6];
|
|
335
335
|
case "com.amazonaws.elasticloadbalancing#TooManyTagsException": return [3, 6];
|
|
336
336
|
}
|
|
337
337
|
return [3, 8];
|
|
338
|
-
case 2: return [4,
|
|
338
|
+
case 2: return [4, deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context)];
|
|
339
339
|
case 3: throw _d.sent();
|
|
340
|
-
case 4: return [4,
|
|
340
|
+
case 4: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
341
341
|
case 5: throw _d.sent();
|
|
342
342
|
case 6: return [4, deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)];
|
|
343
343
|
case 7: throw _d.sent();
|
|
@@ -380,25 +380,25 @@ var deserializeAws_queryApplySecurityGroupsToLoadBalancerCommandError = function
|
|
|
380
380
|
case 0:
|
|
381
381
|
_a = [__assign({}, output)];
|
|
382
382
|
_c = {};
|
|
383
|
-
return [4,
|
|
383
|
+
return [4, parseErrorBody(output.body, context)];
|
|
384
384
|
case 1:
|
|
385
385
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
386
386
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
387
387
|
_b = errorCode;
|
|
388
388
|
switch (_b) {
|
|
389
|
-
case "
|
|
390
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
391
|
-
case "
|
|
392
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
393
|
-
case "
|
|
394
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
389
|
+
case "InvalidConfigurationRequest": return [3, 2];
|
|
390
|
+
case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 2];
|
|
391
|
+
case "InvalidSecurityGroup": return [3, 4];
|
|
392
|
+
case "com.amazonaws.elasticloadbalancing#InvalidSecurityGroupException": return [3, 4];
|
|
393
|
+
case "LoadBalancerNotFound": return [3, 6];
|
|
394
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 6];
|
|
395
395
|
}
|
|
396
396
|
return [3, 8];
|
|
397
|
-
case 2: return [4,
|
|
397
|
+
case 2: return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
|
|
398
398
|
case 3: throw _d.sent();
|
|
399
|
-
case 4: return [4,
|
|
399
|
+
case 4: return [4, deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context)];
|
|
400
400
|
case 5: throw _d.sent();
|
|
401
|
-
case 6: return [4,
|
|
401
|
+
case 6: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
402
402
|
case 7: throw _d.sent();
|
|
403
403
|
case 8:
|
|
404
404
|
parsedBody = parsedOutput.body;
|
|
@@ -439,27 +439,27 @@ var deserializeAws_queryAttachLoadBalancerToSubnetsCommandError = function (outp
|
|
|
439
439
|
case 0:
|
|
440
440
|
_a = [__assign({}, output)];
|
|
441
441
|
_c = {};
|
|
442
|
-
return [4,
|
|
442
|
+
return [4, parseErrorBody(output.body, context)];
|
|
443
443
|
case 1:
|
|
444
444
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
445
445
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
446
446
|
_b = errorCode;
|
|
447
447
|
switch (_b) {
|
|
448
|
-
case "
|
|
449
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
450
|
-
case "
|
|
451
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
452
|
-
case "
|
|
453
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
454
|
-
case "
|
|
448
|
+
case "InvalidConfigurationRequest": return [3, 2];
|
|
449
|
+
case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 2];
|
|
450
|
+
case "InvalidSubnet": return [3, 4];
|
|
451
|
+
case "com.amazonaws.elasticloadbalancing#InvalidSubnetException": return [3, 4];
|
|
452
|
+
case "LoadBalancerNotFound": return [3, 6];
|
|
453
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 6];
|
|
454
|
+
case "SubnetNotFound": return [3, 8];
|
|
455
455
|
case "com.amazonaws.elasticloadbalancing#SubnetNotFoundException": return [3, 8];
|
|
456
456
|
}
|
|
457
457
|
return [3, 10];
|
|
458
|
-
case 2: return [4,
|
|
458
|
+
case 2: return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
|
|
459
459
|
case 3: throw _d.sent();
|
|
460
|
-
case 4: return [4,
|
|
460
|
+
case 4: return [4, deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context)];
|
|
461
461
|
case 5: throw _d.sent();
|
|
462
|
-
case 6: return [4,
|
|
462
|
+
case 6: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
463
463
|
case 7: throw _d.sent();
|
|
464
464
|
case 8: return [4, deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context)];
|
|
465
465
|
case 9: throw _d.sent();
|
|
@@ -502,13 +502,13 @@ var deserializeAws_queryConfigureHealthCheckCommandError = function (output, con
|
|
|
502
502
|
case 0:
|
|
503
503
|
_a = [__assign({}, output)];
|
|
504
504
|
_c = {};
|
|
505
|
-
return [4,
|
|
505
|
+
return [4, parseErrorBody(output.body, context)];
|
|
506
506
|
case 1:
|
|
507
507
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
508
508
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
509
509
|
_b = errorCode;
|
|
510
510
|
switch (_b) {
|
|
511
|
-
case "
|
|
511
|
+
case "LoadBalancerNotFound": return [3, 2];
|
|
512
512
|
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
|
|
513
513
|
}
|
|
514
514
|
return [3, 4];
|
|
@@ -553,27 +553,27 @@ var deserializeAws_queryCreateAppCookieStickinessPolicyCommandError = function (
|
|
|
553
553
|
case 0:
|
|
554
554
|
_a = [__assign({}, output)];
|
|
555
555
|
_c = {};
|
|
556
|
-
return [4,
|
|
556
|
+
return [4, parseErrorBody(output.body, context)];
|
|
557
557
|
case 1:
|
|
558
558
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
559
559
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
560
560
|
_b = errorCode;
|
|
561
561
|
switch (_b) {
|
|
562
|
-
case "
|
|
563
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
564
|
-
case "
|
|
565
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
566
|
-
case "
|
|
567
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
568
|
-
case "
|
|
562
|
+
case "DuplicatePolicyName": return [3, 2];
|
|
563
|
+
case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException": return [3, 2];
|
|
564
|
+
case "InvalidConfigurationRequest": return [3, 4];
|
|
565
|
+
case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 4];
|
|
566
|
+
case "LoadBalancerNotFound": return [3, 6];
|
|
567
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 6];
|
|
568
|
+
case "TooManyPolicies": return [3, 8];
|
|
569
569
|
case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException": return [3, 8];
|
|
570
570
|
}
|
|
571
571
|
return [3, 10];
|
|
572
|
-
case 2: return [4,
|
|
572
|
+
case 2: return [4, deserializeAws_queryDuplicatePolicyNameExceptionResponse(parsedOutput, context)];
|
|
573
573
|
case 3: throw _d.sent();
|
|
574
|
-
case 4: return [4,
|
|
574
|
+
case 4: return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
|
|
575
575
|
case 5: throw _d.sent();
|
|
576
|
-
case 6: return [4,
|
|
576
|
+
case 6: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
577
577
|
case 7: throw _d.sent();
|
|
578
578
|
case 8: return [4, deserializeAws_queryTooManyPoliciesExceptionResponse(parsedOutput, context)];
|
|
579
579
|
case 9: throw _d.sent();
|
|
@@ -616,27 +616,27 @@ var deserializeAws_queryCreateLBCookieStickinessPolicyCommandError = function (o
|
|
|
616
616
|
case 0:
|
|
617
617
|
_a = [__assign({}, output)];
|
|
618
618
|
_c = {};
|
|
619
|
-
return [4,
|
|
619
|
+
return [4, parseErrorBody(output.body, context)];
|
|
620
620
|
case 1:
|
|
621
621
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
622
622
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
623
623
|
_b = errorCode;
|
|
624
624
|
switch (_b) {
|
|
625
|
-
case "
|
|
626
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
627
|
-
case "
|
|
628
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
629
|
-
case "
|
|
630
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
631
|
-
case "
|
|
625
|
+
case "DuplicatePolicyName": return [3, 2];
|
|
626
|
+
case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException": return [3, 2];
|
|
627
|
+
case "InvalidConfigurationRequest": return [3, 4];
|
|
628
|
+
case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 4];
|
|
629
|
+
case "LoadBalancerNotFound": return [3, 6];
|
|
630
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 6];
|
|
631
|
+
case "TooManyPolicies": return [3, 8];
|
|
632
632
|
case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException": return [3, 8];
|
|
633
633
|
}
|
|
634
634
|
return [3, 10];
|
|
635
|
-
case 2: return [4,
|
|
635
|
+
case 2: return [4, deserializeAws_queryDuplicatePolicyNameExceptionResponse(parsedOutput, context)];
|
|
636
636
|
case 3: throw _d.sent();
|
|
637
|
-
case 4: return [4,
|
|
637
|
+
case 4: return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
|
|
638
638
|
case 5: throw _d.sent();
|
|
639
|
-
case 6: return [4,
|
|
639
|
+
case 6: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
640
640
|
case 7: throw _d.sent();
|
|
641
641
|
case 8: return [4, deserializeAws_queryTooManyPoliciesExceptionResponse(parsedOutput, context)];
|
|
642
642
|
case 9: throw _d.sent();
|
|
@@ -679,35 +679,35 @@ var deserializeAws_queryCreateLoadBalancerCommandError = function (output, conte
|
|
|
679
679
|
case 0:
|
|
680
680
|
_a = [__assign({}, output)];
|
|
681
681
|
_c = {};
|
|
682
|
-
return [4,
|
|
682
|
+
return [4, parseErrorBody(output.body, context)];
|
|
683
683
|
case 1:
|
|
684
684
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
685
685
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
686
686
|
_b = errorCode;
|
|
687
687
|
switch (_b) {
|
|
688
|
-
case "
|
|
688
|
+
case "CertificateNotFound": return [3, 2];
|
|
689
689
|
case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException": return [3, 2];
|
|
690
|
-
case "
|
|
690
|
+
case "DuplicateLoadBalancerName": return [3, 4];
|
|
691
691
|
case "com.amazonaws.elasticloadbalancing#DuplicateAccessPointNameException": return [3, 4];
|
|
692
|
-
case "
|
|
692
|
+
case "DuplicateTagKeys": return [3, 6];
|
|
693
693
|
case "com.amazonaws.elasticloadbalancing#DuplicateTagKeysException": return [3, 6];
|
|
694
|
-
case "
|
|
694
|
+
case "InvalidConfigurationRequest": return [3, 8];
|
|
695
695
|
case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 8];
|
|
696
|
-
case "
|
|
696
|
+
case "InvalidScheme": return [3, 10];
|
|
697
697
|
case "com.amazonaws.elasticloadbalancing#InvalidSchemeException": return [3, 10];
|
|
698
|
-
case "
|
|
698
|
+
case "InvalidSecurityGroup": return [3, 12];
|
|
699
699
|
case "com.amazonaws.elasticloadbalancing#InvalidSecurityGroupException": return [3, 12];
|
|
700
|
-
case "
|
|
700
|
+
case "InvalidSubnet": return [3, 14];
|
|
701
701
|
case "com.amazonaws.elasticloadbalancing#InvalidSubnetException": return [3, 14];
|
|
702
|
-
case "
|
|
702
|
+
case "OperationNotPermitted": return [3, 16];
|
|
703
703
|
case "com.amazonaws.elasticloadbalancing#OperationNotPermittedException": return [3, 16];
|
|
704
|
-
case "
|
|
704
|
+
case "SubnetNotFound": return [3, 18];
|
|
705
705
|
case "com.amazonaws.elasticloadbalancing#SubnetNotFoundException": return [3, 18];
|
|
706
|
-
case "
|
|
706
|
+
case "TooManyLoadBalancers": return [3, 20];
|
|
707
707
|
case "com.amazonaws.elasticloadbalancing#TooManyAccessPointsException": return [3, 20];
|
|
708
|
-
case "
|
|
708
|
+
case "TooManyTags": return [3, 22];
|
|
709
709
|
case "com.amazonaws.elasticloadbalancing#TooManyTagsException": return [3, 22];
|
|
710
|
-
case "
|
|
710
|
+
case "UnsupportedProtocol": return [3, 24];
|
|
711
711
|
case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException": return [3, 24];
|
|
712
712
|
}
|
|
713
713
|
return [3, 26];
|
|
@@ -774,31 +774,31 @@ var deserializeAws_queryCreateLoadBalancerListenersCommandError = function (outp
|
|
|
774
774
|
case 0:
|
|
775
775
|
_a = [__assign({}, output)];
|
|
776
776
|
_c = {};
|
|
777
|
-
return [4,
|
|
777
|
+
return [4, parseErrorBody(output.body, context)];
|
|
778
778
|
case 1:
|
|
779
779
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
780
780
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
781
781
|
_b = errorCode;
|
|
782
782
|
switch (_b) {
|
|
783
|
-
case "
|
|
784
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
785
|
-
case "
|
|
786
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
787
|
-
case "
|
|
788
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
789
|
-
case "
|
|
790
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
791
|
-
case "
|
|
783
|
+
case "CertificateNotFound": return [3, 2];
|
|
784
|
+
case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException": return [3, 2];
|
|
785
|
+
case "DuplicateListener": return [3, 4];
|
|
786
|
+
case "com.amazonaws.elasticloadbalancing#DuplicateListenerException": return [3, 4];
|
|
787
|
+
case "InvalidConfigurationRequest": return [3, 6];
|
|
788
|
+
case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 6];
|
|
789
|
+
case "LoadBalancerNotFound": return [3, 8];
|
|
790
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 8];
|
|
791
|
+
case "UnsupportedProtocol": return [3, 10];
|
|
792
792
|
case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException": return [3, 10];
|
|
793
793
|
}
|
|
794
794
|
return [3, 12];
|
|
795
|
-
case 2: return [4,
|
|
795
|
+
case 2: return [4, deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context)];
|
|
796
796
|
case 3: throw _d.sent();
|
|
797
|
-
case 4: return [4,
|
|
797
|
+
case 4: return [4, deserializeAws_queryDuplicateListenerExceptionResponse(parsedOutput, context)];
|
|
798
798
|
case 5: throw _d.sent();
|
|
799
|
-
case 6: return [4,
|
|
799
|
+
case 6: return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
|
|
800
800
|
case 7: throw _d.sent();
|
|
801
|
-
case 8: return [4,
|
|
801
|
+
case 8: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
802
802
|
case 9: throw _d.sent();
|
|
803
803
|
case 10: return [4, deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)];
|
|
804
804
|
case 11: throw _d.sent();
|
|
@@ -841,29 +841,29 @@ var deserializeAws_queryCreateLoadBalancerPolicyCommandError = function (output,
|
|
|
841
841
|
case 0:
|
|
842
842
|
_a = [__assign({}, output)];
|
|
843
843
|
_c = {};
|
|
844
|
-
return [4,
|
|
844
|
+
return [4, parseErrorBody(output.body, context)];
|
|
845
845
|
case 1:
|
|
846
846
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
847
847
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
848
848
|
_b = errorCode;
|
|
849
849
|
switch (_b) {
|
|
850
|
-
case "
|
|
851
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
852
|
-
case "
|
|
853
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
854
|
-
case "
|
|
855
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
856
|
-
case "
|
|
850
|
+
case "DuplicatePolicyName": return [3, 2];
|
|
851
|
+
case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException": return [3, 2];
|
|
852
|
+
case "InvalidConfigurationRequest": return [3, 4];
|
|
853
|
+
case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 4];
|
|
854
|
+
case "LoadBalancerNotFound": return [3, 6];
|
|
855
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 6];
|
|
856
|
+
case "PolicyTypeNotFound": return [3, 8];
|
|
857
857
|
case "com.amazonaws.elasticloadbalancing#PolicyTypeNotFoundException": return [3, 8];
|
|
858
|
-
case "
|
|
858
|
+
case "TooManyPolicies": return [3, 10];
|
|
859
859
|
case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException": return [3, 10];
|
|
860
860
|
}
|
|
861
861
|
return [3, 12];
|
|
862
|
-
case 2: return [4,
|
|
862
|
+
case 2: return [4, deserializeAws_queryDuplicatePolicyNameExceptionResponse(parsedOutput, context)];
|
|
863
863
|
case 3: throw _d.sent();
|
|
864
|
-
case 4: return [4,
|
|
864
|
+
case 4: return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
|
|
865
865
|
case 5: throw _d.sent();
|
|
866
|
-
case 6: return [4,
|
|
866
|
+
case 6: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
867
867
|
case 7: throw _d.sent();
|
|
868
868
|
case 8: return [4, deserializeAws_queryPolicyTypeNotFoundExceptionResponse(parsedOutput, context)];
|
|
869
869
|
case 9: throw _d.sent();
|
|
@@ -908,7 +908,7 @@ var deserializeAws_queryDeleteLoadBalancerCommandError = function (output, conte
|
|
|
908
908
|
case 0:
|
|
909
909
|
_a = [__assign({}, output)];
|
|
910
910
|
_b = {};
|
|
911
|
-
return [4,
|
|
911
|
+
return [4, parseErrorBody(output.body, context)];
|
|
912
912
|
case 1:
|
|
913
913
|
parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
|
|
914
914
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
@@ -949,13 +949,13 @@ var deserializeAws_queryDeleteLoadBalancerListenersCommandError = function (outp
|
|
|
949
949
|
case 0:
|
|
950
950
|
_a = [__assign({}, output)];
|
|
951
951
|
_c = {};
|
|
952
|
-
return [4,
|
|
952
|
+
return [4, parseErrorBody(output.body, context)];
|
|
953
953
|
case 1:
|
|
954
954
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
955
955
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
956
956
|
_b = errorCode;
|
|
957
957
|
switch (_b) {
|
|
958
|
-
case "
|
|
958
|
+
case "LoadBalancerNotFound": return [3, 2];
|
|
959
959
|
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
|
|
960
960
|
}
|
|
961
961
|
return [3, 4];
|
|
@@ -1000,21 +1000,21 @@ var deserializeAws_queryDeleteLoadBalancerPolicyCommandError = function (output,
|
|
|
1000
1000
|
case 0:
|
|
1001
1001
|
_a = [__assign({}, output)];
|
|
1002
1002
|
_c = {};
|
|
1003
|
-
return [4,
|
|
1003
|
+
return [4, parseErrorBody(output.body, context)];
|
|
1004
1004
|
case 1:
|
|
1005
1005
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
1006
1006
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1007
1007
|
_b = errorCode;
|
|
1008
1008
|
switch (_b) {
|
|
1009
|
-
case "
|
|
1010
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1011
|
-
case "
|
|
1012
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1009
|
+
case "InvalidConfigurationRequest": return [3, 2];
|
|
1010
|
+
case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 2];
|
|
1011
|
+
case "LoadBalancerNotFound": return [3, 4];
|
|
1012
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 4];
|
|
1013
1013
|
}
|
|
1014
1014
|
return [3, 6];
|
|
1015
|
-
case 2: return [4,
|
|
1015
|
+
case 2: return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
|
|
1016
1016
|
case 3: throw _d.sent();
|
|
1017
|
-
case 4: return [4,
|
|
1017
|
+
case 4: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
1018
1018
|
case 5: throw _d.sent();
|
|
1019
1019
|
case 6:
|
|
1020
1020
|
parsedBody = parsedOutput.body;
|
|
@@ -1055,21 +1055,21 @@ var deserializeAws_queryDeregisterInstancesFromLoadBalancerCommandError = functi
|
|
|
1055
1055
|
case 0:
|
|
1056
1056
|
_a = [__assign({}, output)];
|
|
1057
1057
|
_c = {};
|
|
1058
|
-
return [4,
|
|
1058
|
+
return [4, parseErrorBody(output.body, context)];
|
|
1059
1059
|
case 1:
|
|
1060
1060
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
1061
1061
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1062
1062
|
_b = errorCode;
|
|
1063
1063
|
switch (_b) {
|
|
1064
|
-
case "
|
|
1065
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1066
|
-
case "
|
|
1067
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1064
|
+
case "InvalidInstance": return [3, 2];
|
|
1065
|
+
case "com.amazonaws.elasticloadbalancing#InvalidEndPointException": return [3, 2];
|
|
1066
|
+
case "LoadBalancerNotFound": return [3, 4];
|
|
1067
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 4];
|
|
1068
1068
|
}
|
|
1069
1069
|
return [3, 6];
|
|
1070
|
-
case 2: return [4,
|
|
1070
|
+
case 2: return [4, deserializeAws_queryInvalidEndPointExceptionResponse(parsedOutput, context)];
|
|
1071
1071
|
case 3: throw _d.sent();
|
|
1072
|
-
case 4: return [4,
|
|
1072
|
+
case 4: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
1073
1073
|
case 5: throw _d.sent();
|
|
1074
1074
|
case 6:
|
|
1075
1075
|
parsedBody = parsedOutput.body;
|
|
@@ -1110,7 +1110,7 @@ var deserializeAws_queryDescribeAccountLimitsCommandError = function (output, co
|
|
|
1110
1110
|
case 0:
|
|
1111
1111
|
_a = [__assign({}, output)];
|
|
1112
1112
|
_b = {};
|
|
1113
|
-
return [4,
|
|
1113
|
+
return [4, parseErrorBody(output.body, context)];
|
|
1114
1114
|
case 1:
|
|
1115
1115
|
parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
|
|
1116
1116
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
@@ -1151,21 +1151,21 @@ var deserializeAws_queryDescribeInstanceHealthCommandError = function (output, c
|
|
|
1151
1151
|
case 0:
|
|
1152
1152
|
_a = [__assign({}, output)];
|
|
1153
1153
|
_c = {};
|
|
1154
|
-
return [4,
|
|
1154
|
+
return [4, parseErrorBody(output.body, context)];
|
|
1155
1155
|
case 1:
|
|
1156
1156
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
1157
1157
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1158
1158
|
_b = errorCode;
|
|
1159
1159
|
switch (_b) {
|
|
1160
|
-
case "
|
|
1161
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1162
|
-
case "
|
|
1163
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1160
|
+
case "InvalidInstance": return [3, 2];
|
|
1161
|
+
case "com.amazonaws.elasticloadbalancing#InvalidEndPointException": return [3, 2];
|
|
1162
|
+
case "LoadBalancerNotFound": return [3, 4];
|
|
1163
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 4];
|
|
1164
1164
|
}
|
|
1165
1165
|
return [3, 6];
|
|
1166
|
-
case 2: return [4,
|
|
1166
|
+
case 2: return [4, deserializeAws_queryInvalidEndPointExceptionResponse(parsedOutput, context)];
|
|
1167
1167
|
case 3: throw _d.sent();
|
|
1168
|
-
case 4: return [4,
|
|
1168
|
+
case 4: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
1169
1169
|
case 5: throw _d.sent();
|
|
1170
1170
|
case 6:
|
|
1171
1171
|
parsedBody = parsedOutput.body;
|
|
@@ -1206,21 +1206,21 @@ var deserializeAws_queryDescribeLoadBalancerAttributesCommandError = function (o
|
|
|
1206
1206
|
case 0:
|
|
1207
1207
|
_a = [__assign({}, output)];
|
|
1208
1208
|
_c = {};
|
|
1209
|
-
return [4,
|
|
1209
|
+
return [4, parseErrorBody(output.body, context)];
|
|
1210
1210
|
case 1:
|
|
1211
1211
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
1212
1212
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1213
1213
|
_b = errorCode;
|
|
1214
1214
|
switch (_b) {
|
|
1215
|
-
case "
|
|
1216
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1217
|
-
case "
|
|
1218
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1215
|
+
case "LoadBalancerAttributeNotFound": return [3, 2];
|
|
1216
|
+
case "com.amazonaws.elasticloadbalancing#LoadBalancerAttributeNotFoundException": return [3, 2];
|
|
1217
|
+
case "LoadBalancerNotFound": return [3, 4];
|
|
1218
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 4];
|
|
1219
1219
|
}
|
|
1220
1220
|
return [3, 6];
|
|
1221
|
-
case 2: return [4,
|
|
1221
|
+
case 2: return [4, deserializeAws_queryLoadBalancerAttributeNotFoundExceptionResponse(parsedOutput, context)];
|
|
1222
1222
|
case 3: throw _d.sent();
|
|
1223
|
-
case 4: return [4,
|
|
1223
|
+
case 4: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
1224
1224
|
case 5: throw _d.sent();
|
|
1225
1225
|
case 6:
|
|
1226
1226
|
parsedBody = parsedOutput.body;
|
|
@@ -1261,15 +1261,15 @@ var deserializeAws_queryDescribeLoadBalancerPoliciesCommandError = function (out
|
|
|
1261
1261
|
case 0:
|
|
1262
1262
|
_a = [__assign({}, output)];
|
|
1263
1263
|
_c = {};
|
|
1264
|
-
return [4,
|
|
1264
|
+
return [4, parseErrorBody(output.body, context)];
|
|
1265
1265
|
case 1:
|
|
1266
1266
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
1267
1267
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1268
1268
|
_b = errorCode;
|
|
1269
1269
|
switch (_b) {
|
|
1270
|
-
case "
|
|
1270
|
+
case "LoadBalancerNotFound": return [3, 2];
|
|
1271
1271
|
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
|
|
1272
|
-
case "
|
|
1272
|
+
case "PolicyNotFound": return [3, 4];
|
|
1273
1273
|
case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException": return [3, 4];
|
|
1274
1274
|
}
|
|
1275
1275
|
return [3, 6];
|
|
@@ -1316,13 +1316,13 @@ var deserializeAws_queryDescribeLoadBalancerPolicyTypesCommandError = function (
|
|
|
1316
1316
|
case 0:
|
|
1317
1317
|
_a = [__assign({}, output)];
|
|
1318
1318
|
_c = {};
|
|
1319
|
-
return [4,
|
|
1319
|
+
return [4, parseErrorBody(output.body, context)];
|
|
1320
1320
|
case 1:
|
|
1321
1321
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
1322
1322
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1323
1323
|
_b = errorCode;
|
|
1324
1324
|
switch (_b) {
|
|
1325
|
-
case "
|
|
1325
|
+
case "PolicyTypeNotFound": return [3, 2];
|
|
1326
1326
|
case "com.amazonaws.elasticloadbalancing#PolicyTypeNotFoundException": return [3, 2];
|
|
1327
1327
|
}
|
|
1328
1328
|
return [3, 4];
|
|
@@ -1367,21 +1367,21 @@ var deserializeAws_queryDescribeLoadBalancersCommandError = function (output, co
|
|
|
1367
1367
|
case 0:
|
|
1368
1368
|
_a = [__assign({}, output)];
|
|
1369
1369
|
_c = {};
|
|
1370
|
-
return [4,
|
|
1370
|
+
return [4, parseErrorBody(output.body, context)];
|
|
1371
1371
|
case 1:
|
|
1372
1372
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
1373
1373
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1374
1374
|
_b = errorCode;
|
|
1375
1375
|
switch (_b) {
|
|
1376
|
-
case "
|
|
1377
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1378
|
-
case "
|
|
1379
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1376
|
+
case "DependencyThrottle": return [3, 2];
|
|
1377
|
+
case "com.amazonaws.elasticloadbalancing#DependencyThrottleException": return [3, 2];
|
|
1378
|
+
case "LoadBalancerNotFound": return [3, 4];
|
|
1379
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 4];
|
|
1380
1380
|
}
|
|
1381
1381
|
return [3, 6];
|
|
1382
|
-
case 2: return [4,
|
|
1382
|
+
case 2: return [4, deserializeAws_queryDependencyThrottleExceptionResponse(parsedOutput, context)];
|
|
1383
1383
|
case 3: throw _d.sent();
|
|
1384
|
-
case 4: return [4,
|
|
1384
|
+
case 4: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
1385
1385
|
case 5: throw _d.sent();
|
|
1386
1386
|
case 6:
|
|
1387
1387
|
parsedBody = parsedOutput.body;
|
|
@@ -1422,13 +1422,13 @@ var deserializeAws_queryDescribeTagsCommandError = function (output, context) {
|
|
|
1422
1422
|
case 0:
|
|
1423
1423
|
_a = [__assign({}, output)];
|
|
1424
1424
|
_c = {};
|
|
1425
|
-
return [4,
|
|
1425
|
+
return [4, parseErrorBody(output.body, context)];
|
|
1426
1426
|
case 1:
|
|
1427
1427
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
1428
1428
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1429
1429
|
_b = errorCode;
|
|
1430
1430
|
switch (_b) {
|
|
1431
|
-
case "
|
|
1431
|
+
case "LoadBalancerNotFound": return [3, 2];
|
|
1432
1432
|
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
|
|
1433
1433
|
}
|
|
1434
1434
|
return [3, 4];
|
|
@@ -1473,21 +1473,21 @@ var deserializeAws_queryDetachLoadBalancerFromSubnetsCommandError = function (ou
|
|
|
1473
1473
|
case 0:
|
|
1474
1474
|
_a = [__assign({}, output)];
|
|
1475
1475
|
_c = {};
|
|
1476
|
-
return [4,
|
|
1476
|
+
return [4, parseErrorBody(output.body, context)];
|
|
1477
1477
|
case 1:
|
|
1478
1478
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
1479
1479
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1480
1480
|
_b = errorCode;
|
|
1481
1481
|
switch (_b) {
|
|
1482
|
-
case "
|
|
1483
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1484
|
-
case "
|
|
1485
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1482
|
+
case "InvalidConfigurationRequest": return [3, 2];
|
|
1483
|
+
case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 2];
|
|
1484
|
+
case "LoadBalancerNotFound": return [3, 4];
|
|
1485
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 4];
|
|
1486
1486
|
}
|
|
1487
1487
|
return [3, 6];
|
|
1488
|
-
case 2: return [4,
|
|
1488
|
+
case 2: return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
|
|
1489
1489
|
case 3: throw _d.sent();
|
|
1490
|
-
case 4: return [4,
|
|
1490
|
+
case 4: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
1491
1491
|
case 5: throw _d.sent();
|
|
1492
1492
|
case 6:
|
|
1493
1493
|
parsedBody = parsedOutput.body;
|
|
@@ -1528,21 +1528,21 @@ var deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommandError = fu
|
|
|
1528
1528
|
case 0:
|
|
1529
1529
|
_a = [__assign({}, output)];
|
|
1530
1530
|
_c = {};
|
|
1531
|
-
return [4,
|
|
1531
|
+
return [4, parseErrorBody(output.body, context)];
|
|
1532
1532
|
case 1:
|
|
1533
1533
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
1534
1534
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1535
1535
|
_b = errorCode;
|
|
1536
1536
|
switch (_b) {
|
|
1537
|
-
case "
|
|
1538
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1539
|
-
case "
|
|
1540
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1537
|
+
case "InvalidConfigurationRequest": return [3, 2];
|
|
1538
|
+
case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 2];
|
|
1539
|
+
case "LoadBalancerNotFound": return [3, 4];
|
|
1540
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 4];
|
|
1541
1541
|
}
|
|
1542
1542
|
return [3, 6];
|
|
1543
|
-
case 2: return [4,
|
|
1543
|
+
case 2: return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
|
|
1544
1544
|
case 3: throw _d.sent();
|
|
1545
|
-
case 4: return [4,
|
|
1545
|
+
case 4: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
1546
1546
|
case 5: throw _d.sent();
|
|
1547
1547
|
case 6:
|
|
1548
1548
|
parsedBody = parsedOutput.body;
|
|
@@ -1583,13 +1583,13 @@ var deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommandError = fun
|
|
|
1583
1583
|
case 0:
|
|
1584
1584
|
_a = [__assign({}, output)];
|
|
1585
1585
|
_c = {};
|
|
1586
|
-
return [4,
|
|
1586
|
+
return [4, parseErrorBody(output.body, context)];
|
|
1587
1587
|
case 1:
|
|
1588
1588
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
1589
1589
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1590
1590
|
_b = errorCode;
|
|
1591
1591
|
switch (_b) {
|
|
1592
|
-
case "
|
|
1592
|
+
case "LoadBalancerNotFound": return [3, 2];
|
|
1593
1593
|
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
|
|
1594
1594
|
}
|
|
1595
1595
|
return [3, 4];
|
|
@@ -1634,25 +1634,25 @@ var deserializeAws_queryModifyLoadBalancerAttributesCommandError = function (out
|
|
|
1634
1634
|
case 0:
|
|
1635
1635
|
_a = [__assign({}, output)];
|
|
1636
1636
|
_c = {};
|
|
1637
|
-
return [4,
|
|
1637
|
+
return [4, parseErrorBody(output.body, context)];
|
|
1638
1638
|
case 1:
|
|
1639
1639
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
1640
1640
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1641
1641
|
_b = errorCode;
|
|
1642
1642
|
switch (_b) {
|
|
1643
|
-
case "
|
|
1644
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1645
|
-
case "
|
|
1646
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1647
|
-
case "
|
|
1648
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1643
|
+
case "InvalidConfigurationRequest": return [3, 2];
|
|
1644
|
+
case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 2];
|
|
1645
|
+
case "LoadBalancerAttributeNotFound": return [3, 4];
|
|
1646
|
+
case "com.amazonaws.elasticloadbalancing#LoadBalancerAttributeNotFoundException": return [3, 4];
|
|
1647
|
+
case "LoadBalancerNotFound": return [3, 6];
|
|
1648
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 6];
|
|
1649
1649
|
}
|
|
1650
1650
|
return [3, 8];
|
|
1651
|
-
case 2: return [4,
|
|
1651
|
+
case 2: return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
|
|
1652
1652
|
case 3: throw _d.sent();
|
|
1653
|
-
case 4: return [4,
|
|
1653
|
+
case 4: return [4, deserializeAws_queryLoadBalancerAttributeNotFoundExceptionResponse(parsedOutput, context)];
|
|
1654
1654
|
case 5: throw _d.sent();
|
|
1655
|
-
case 6: return [4,
|
|
1655
|
+
case 6: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
1656
1656
|
case 7: throw _d.sent();
|
|
1657
1657
|
case 8:
|
|
1658
1658
|
parsedBody = parsedOutput.body;
|
|
@@ -1693,21 +1693,21 @@ var deserializeAws_queryRegisterInstancesWithLoadBalancerCommandError = function
|
|
|
1693
1693
|
case 0:
|
|
1694
1694
|
_a = [__assign({}, output)];
|
|
1695
1695
|
_c = {};
|
|
1696
|
-
return [4,
|
|
1696
|
+
return [4, parseErrorBody(output.body, context)];
|
|
1697
1697
|
case 1:
|
|
1698
1698
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
1699
1699
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1700
1700
|
_b = errorCode;
|
|
1701
1701
|
switch (_b) {
|
|
1702
|
-
case "
|
|
1703
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1704
|
-
case "
|
|
1705
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1702
|
+
case "InvalidInstance": return [3, 2];
|
|
1703
|
+
case "com.amazonaws.elasticloadbalancing#InvalidEndPointException": return [3, 2];
|
|
1704
|
+
case "LoadBalancerNotFound": return [3, 4];
|
|
1705
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 4];
|
|
1706
1706
|
}
|
|
1707
1707
|
return [3, 6];
|
|
1708
|
-
case 2: return [4,
|
|
1708
|
+
case 2: return [4, deserializeAws_queryInvalidEndPointExceptionResponse(parsedOutput, context)];
|
|
1709
1709
|
case 3: throw _d.sent();
|
|
1710
|
-
case 4: return [4,
|
|
1710
|
+
case 4: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
1711
1711
|
case 5: throw _d.sent();
|
|
1712
1712
|
case 6:
|
|
1713
1713
|
parsedBody = parsedOutput.body;
|
|
@@ -1748,13 +1748,13 @@ var deserializeAws_queryRemoveTagsCommandError = function (output, context) { re
|
|
|
1748
1748
|
case 0:
|
|
1749
1749
|
_a = [__assign({}, output)];
|
|
1750
1750
|
_c = {};
|
|
1751
|
-
return [4,
|
|
1751
|
+
return [4, parseErrorBody(output.body, context)];
|
|
1752
1752
|
case 1:
|
|
1753
1753
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
1754
1754
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1755
1755
|
_b = errorCode;
|
|
1756
1756
|
switch (_b) {
|
|
1757
|
-
case "
|
|
1757
|
+
case "LoadBalancerNotFound": return [3, 2];
|
|
1758
1758
|
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
|
|
1759
1759
|
}
|
|
1760
1760
|
return [3, 4];
|
|
@@ -1799,31 +1799,31 @@ var deserializeAws_querySetLoadBalancerListenerSSLCertificateCommandError = func
|
|
|
1799
1799
|
case 0:
|
|
1800
1800
|
_a = [__assign({}, output)];
|
|
1801
1801
|
_c = {};
|
|
1802
|
-
return [4,
|
|
1802
|
+
return [4, parseErrorBody(output.body, context)];
|
|
1803
1803
|
case 1:
|
|
1804
1804
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
1805
1805
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1806
1806
|
_b = errorCode;
|
|
1807
1807
|
switch (_b) {
|
|
1808
|
-
case "
|
|
1809
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1810
|
-
case "
|
|
1811
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1812
|
-
case "
|
|
1813
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1814
|
-
case "
|
|
1815
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1816
|
-
case "
|
|
1808
|
+
case "CertificateNotFound": return [3, 2];
|
|
1809
|
+
case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException": return [3, 2];
|
|
1810
|
+
case "InvalidConfigurationRequest": return [3, 4];
|
|
1811
|
+
case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 4];
|
|
1812
|
+
case "ListenerNotFound": return [3, 6];
|
|
1813
|
+
case "com.amazonaws.elasticloadbalancing#ListenerNotFoundException": return [3, 6];
|
|
1814
|
+
case "LoadBalancerNotFound": return [3, 8];
|
|
1815
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 8];
|
|
1816
|
+
case "UnsupportedProtocol": return [3, 10];
|
|
1817
1817
|
case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException": return [3, 10];
|
|
1818
1818
|
}
|
|
1819
1819
|
return [3, 12];
|
|
1820
|
-
case 2: return [4,
|
|
1820
|
+
case 2: return [4, deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context)];
|
|
1821
1821
|
case 3: throw _d.sent();
|
|
1822
|
-
case 4: return [4,
|
|
1822
|
+
case 4: return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
|
|
1823
1823
|
case 5: throw _d.sent();
|
|
1824
|
-
case 6: return [4,
|
|
1824
|
+
case 6: return [4, deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)];
|
|
1825
1825
|
case 7: throw _d.sent();
|
|
1826
|
-
case 8: return [4,
|
|
1826
|
+
case 8: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
1827
1827
|
case 9: throw _d.sent();
|
|
1828
1828
|
case 10: return [4, deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)];
|
|
1829
1829
|
case 11: throw _d.sent();
|
|
@@ -1866,23 +1866,23 @@ var deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommandError = fu
|
|
|
1866
1866
|
case 0:
|
|
1867
1867
|
_a = [__assign({}, output)];
|
|
1868
1868
|
_c = {};
|
|
1869
|
-
return [4,
|
|
1869
|
+
return [4, parseErrorBody(output.body, context)];
|
|
1870
1870
|
case 1:
|
|
1871
1871
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
1872
1872
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1873
1873
|
_b = errorCode;
|
|
1874
1874
|
switch (_b) {
|
|
1875
|
-
case "
|
|
1876
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1877
|
-
case "
|
|
1878
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1879
|
-
case "
|
|
1875
|
+
case "InvalidConfigurationRequest": return [3, 2];
|
|
1876
|
+
case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 2];
|
|
1877
|
+
case "LoadBalancerNotFound": return [3, 4];
|
|
1878
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 4];
|
|
1879
|
+
case "PolicyNotFound": return [3, 6];
|
|
1880
1880
|
case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException": return [3, 6];
|
|
1881
1881
|
}
|
|
1882
1882
|
return [3, 8];
|
|
1883
|
-
case 2: return [4,
|
|
1883
|
+
case 2: return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
|
|
1884
1884
|
case 3: throw _d.sent();
|
|
1885
|
-
case 4: return [4,
|
|
1885
|
+
case 4: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
1886
1886
|
case 5: throw _d.sent();
|
|
1887
1887
|
case 6: return [4, deserializeAws_queryPolicyNotFoundExceptionResponse(parsedOutput, context)];
|
|
1888
1888
|
case 7: throw _d.sent();
|
|
@@ -1925,27 +1925,27 @@ var deserializeAws_querySetLoadBalancerPoliciesOfListenerCommandError = function
|
|
|
1925
1925
|
case 0:
|
|
1926
1926
|
_a = [__assign({}, output)];
|
|
1927
1927
|
_c = {};
|
|
1928
|
-
return [4,
|
|
1928
|
+
return [4, parseErrorBody(output.body, context)];
|
|
1929
1929
|
case 1:
|
|
1930
1930
|
parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
|
|
1931
1931
|
errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1932
1932
|
_b = errorCode;
|
|
1933
1933
|
switch (_b) {
|
|
1934
|
-
case "
|
|
1935
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1936
|
-
case "
|
|
1937
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1938
|
-
case "
|
|
1939
|
-
case "com.amazonaws.elasticloadbalancing#
|
|
1940
|
-
case "
|
|
1934
|
+
case "InvalidConfigurationRequest": return [3, 2];
|
|
1935
|
+
case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 2];
|
|
1936
|
+
case "ListenerNotFound": return [3, 4];
|
|
1937
|
+
case "com.amazonaws.elasticloadbalancing#ListenerNotFoundException": return [3, 4];
|
|
1938
|
+
case "LoadBalancerNotFound": return [3, 6];
|
|
1939
|
+
case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 6];
|
|
1940
|
+
case "PolicyNotFound": return [3, 8];
|
|
1941
1941
|
case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException": return [3, 8];
|
|
1942
1942
|
}
|
|
1943
1943
|
return [3, 10];
|
|
1944
|
-
case 2: return [4,
|
|
1944
|
+
case 2: return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
|
|
1945
1945
|
case 3: throw _d.sent();
|
|
1946
|
-
case 4: return [4,
|
|
1946
|
+
case 4: return [4, deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)];
|
|
1947
1947
|
case 5: throw _d.sent();
|
|
1948
|
-
case 6: return [4,
|
|
1948
|
+
case 6: return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
|
|
1949
1949
|
case 7: throw _d.sent();
|
|
1950
1950
|
case 8: return [4, deserializeAws_queryPolicyNotFoundExceptionResponse(parsedOutput, context)];
|
|
1951
1951
|
case 9: throw _d.sent();
|
|
@@ -4262,6 +4262,21 @@ var parseBody = function (streamBody, context) {
|
|
|
4262
4262
|
return {};
|
|
4263
4263
|
});
|
|
4264
4264
|
};
|
|
4265
|
+
var parseErrorBody = function (errorBody, context) { return __awaiter(void 0, void 0, void 0, function () {
|
|
4266
|
+
var value;
|
|
4267
|
+
var _a;
|
|
4268
|
+
return __generator(this, function (_b) {
|
|
4269
|
+
switch (_b.label) {
|
|
4270
|
+
case 0: return [4, parseBody(errorBody, context)];
|
|
4271
|
+
case 1:
|
|
4272
|
+
value = _b.sent();
|
|
4273
|
+
if (value.Error) {
|
|
4274
|
+
value.Error.message = (_a = value.Error.message) !== null && _a !== void 0 ? _a : value.Error.Message;
|
|
4275
|
+
}
|
|
4276
|
+
return [2, value];
|
|
4277
|
+
}
|
|
4278
|
+
});
|
|
4279
|
+
}); };
|
|
4265
4280
|
var buildFormUrlencodedString = function (formEntries) {
|
|
4266
4281
|
return Object.entries(formEntries)
|
|
4267
4282
|
.map(function (_a) {
|