@aws-sdk/client-direct-connect 3.504.0 → 3.507.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 (3) hide show
  1. package/dist-cjs/index.js +100 -1524
  2. package/dist-es/protocols/Aws_json1_1.js +92 -1516
  3. package/package.json +3 -3
package/dist-es/protocols/Aws_json1_1.js CHANGED
@@ -379,7 +379,7 @@ export const se_UpdateVirtualInterfaceAttributesCommand = async (input, context)
379
379
  };
380
380
  export const de_AcceptDirectConnectGatewayAssociationProposalCommand = async (output, context) => {
381
381
  if (output.statusCode >= 300) {
382
- return de_AcceptDirectConnectGatewayAssociationProposalCommandError(output, context);
382
+ return de_CommandError(output, context);
383
383
  }
384
384
  const data = await parseBody(output.body, context);
385
385
  let contents = {};
@@ -390,31 +390,9 @@ export const de_AcceptDirectConnectGatewayAssociationProposalCommand = async (ou
390
390
  };
391
391
  return response;
392
392
  };
393
- const de_AcceptDirectConnectGatewayAssociationProposalCommandError = async (output, context) => {
394
- const parsedOutput = {
395
- ...output,
396
- body: await parseErrorBody(output.body, context),
397
- };
398
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
399
- switch (errorCode) {
400
- case "DirectConnectClientException":
401
- case "com.amazonaws.directconnect#DirectConnectClientException":
402
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
403
- case "DirectConnectServerException":
404
- case "com.amazonaws.directconnect#DirectConnectServerException":
405
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
406
- default:
407
- const parsedBody = parsedOutput.body;
408
- return throwDefaultError({
409
- output,
410
- parsedBody,
411
- errorCode,
412
- });
413
- }
414
- };
415
393
  export const de_AllocateConnectionOnInterconnectCommand = async (output, context) => {
416
394
  if (output.statusCode >= 300) {
417
- return de_AllocateConnectionOnInterconnectCommandError(output, context);
395
+ return de_CommandError(output, context);
418
396
  }
419
397
  const data = await parseBody(output.body, context);
420
398
  let contents = {};
@@ -425,31 +403,9 @@ export const de_AllocateConnectionOnInterconnectCommand = async (output, context
425
403
  };
426
404
  return response;
427
405
  };
428
- const de_AllocateConnectionOnInterconnectCommandError = async (output, context) => {
429
- const parsedOutput = {
430
- ...output,
431
- body: await parseErrorBody(output.body, context),
432
- };
433
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
434
- switch (errorCode) {
435
- case "DirectConnectClientException":
436
- case "com.amazonaws.directconnect#DirectConnectClientException":
437
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
438
- case "DirectConnectServerException":
439
- case "com.amazonaws.directconnect#DirectConnectServerException":
440
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
441
- default:
442
- const parsedBody = parsedOutput.body;
443
- return throwDefaultError({
444
- output,
445
- parsedBody,
446
- errorCode,
447
- });
448
- }
449
- };
450
406
  export const de_AllocateHostedConnectionCommand = async (output, context) => {
451
407
  if (output.statusCode >= 300) {
452
- return de_AllocateHostedConnectionCommandError(output, context);
408
+ return de_CommandError(output, context);
453
409
  }
454
410
  const data = await parseBody(output.body, context);
455
411
  let contents = {};
@@ -460,37 +416,9 @@ export const de_AllocateHostedConnectionCommand = async (output, context) => {
460
416
  };
461
417
  return response;
462
418
  };
463
- const de_AllocateHostedConnectionCommandError = async (output, context) => {
464
- const parsedOutput = {
465
- ...output,
466
- body: await parseErrorBody(output.body, context),
467
- };
468
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
469
- switch (errorCode) {
470
- case "DirectConnectClientException":
471
- case "com.amazonaws.directconnect#DirectConnectClientException":
472
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
473
- case "DirectConnectServerException":
474
- case "com.amazonaws.directconnect#DirectConnectServerException":
475
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
476
- case "DuplicateTagKeysException":
477
- case "com.amazonaws.directconnect#DuplicateTagKeysException":
478
- throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
479
- case "TooManyTagsException":
480
- case "com.amazonaws.directconnect#TooManyTagsException":
481
- throw await de_TooManyTagsExceptionRes(parsedOutput, context);
482
- default:
483
- const parsedBody = parsedOutput.body;
484
- return throwDefaultError({
485
- output,
486
- parsedBody,
487
- errorCode,
488
- });
489
- }
490
- };
491
419
  export const de_AllocatePrivateVirtualInterfaceCommand = async (output, context) => {
492
420
  if (output.statusCode >= 300) {
493
- return de_AllocatePrivateVirtualInterfaceCommandError(output, context);
421
+ return de_CommandError(output, context);
494
422
  }
495
423
  const data = await parseBody(output.body, context);
496
424
  let contents = {};
@@ -501,37 +429,9 @@ export const de_AllocatePrivateVirtualInterfaceCommand = async (output, context)
501
429
  };
502
430
  return response;
503
431
  };
504
- const de_AllocatePrivateVirtualInterfaceCommandError = async (output, context) => {
505
- const parsedOutput = {
506
- ...output,
507
- body: await parseErrorBody(output.body, context),
508
- };
509
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
510
- switch (errorCode) {
511
- case "DirectConnectClientException":
512
- case "com.amazonaws.directconnect#DirectConnectClientException":
513
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
514
- case "DirectConnectServerException":
515
- case "com.amazonaws.directconnect#DirectConnectServerException":
516
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
517
- case "DuplicateTagKeysException":
518
- case "com.amazonaws.directconnect#DuplicateTagKeysException":
519
- throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
520
- case "TooManyTagsException":
521
- case "com.amazonaws.directconnect#TooManyTagsException":
522
- throw await de_TooManyTagsExceptionRes(parsedOutput, context);
523
- default:
524
- const parsedBody = parsedOutput.body;
525
- return throwDefaultError({
526
- output,
527
- parsedBody,
528
- errorCode,
529
- });
530
- }
531
- };
532
432
  export const de_AllocatePublicVirtualInterfaceCommand = async (output, context) => {
533
433
  if (output.statusCode >= 300) {
534
- return de_AllocatePublicVirtualInterfaceCommandError(output, context);
434
+ return de_CommandError(output, context);
535
435
  }
536
436
  const data = await parseBody(output.body, context);
537
437
  let contents = {};
@@ -542,37 +442,9 @@ export const de_AllocatePublicVirtualInterfaceCommand = async (output, context)
542
442
  };
543
443
  return response;
544
444
  };
545
- const de_AllocatePublicVirtualInterfaceCommandError = async (output, context) => {
546
- const parsedOutput = {
547
- ...output,
548
- body: await parseErrorBody(output.body, context),
549
- };
550
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
551
- switch (errorCode) {
552
- case "DirectConnectClientException":
553
- case "com.amazonaws.directconnect#DirectConnectClientException":
554
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
555
- case "DirectConnectServerException":
556
- case "com.amazonaws.directconnect#DirectConnectServerException":
557
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
558
- case "DuplicateTagKeysException":
559
- case "com.amazonaws.directconnect#DuplicateTagKeysException":
560
- throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
561
- case "TooManyTagsException":
562
- case "com.amazonaws.directconnect#TooManyTagsException":
563
- throw await de_TooManyTagsExceptionRes(parsedOutput, context);
564
- default:
565
- const parsedBody = parsedOutput.body;
566
- return throwDefaultError({
567
- output,
568
- parsedBody,
569
- errorCode,
570
- });
571
- }
572
- };
573
445
  export const de_AllocateTransitVirtualInterfaceCommand = async (output, context) => {
574
446
  if (output.statusCode >= 300) {
575
- return de_AllocateTransitVirtualInterfaceCommandError(output, context);
447
+ return de_CommandError(output, context);
576
448
  }
577
449
  const data = await parseBody(output.body, context);
578
450
  let contents = {};
@@ -583,37 +455,9 @@ export const de_AllocateTransitVirtualInterfaceCommand = async (output, context)
583
455
  };
584
456
  return response;
585
457
  };
586
- const de_AllocateTransitVirtualInterfaceCommandError = async (output, context) => {
587
- const parsedOutput = {
588
- ...output,
589
- body: await parseErrorBody(output.body, context),
590
- };
591
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
592
- switch (errorCode) {
593
- case "DirectConnectClientException":
594
- case "com.amazonaws.directconnect#DirectConnectClientException":
595
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
596
- case "DirectConnectServerException":
597
- case "com.amazonaws.directconnect#DirectConnectServerException":
598
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
599
- case "DuplicateTagKeysException":
600
- case "com.amazonaws.directconnect#DuplicateTagKeysException":
601
- throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
602
- case "TooManyTagsException":
603
- case "com.amazonaws.directconnect#TooManyTagsException":
604
- throw await de_TooManyTagsExceptionRes(parsedOutput, context);
605
- default:
606
- const parsedBody = parsedOutput.body;
607
- return throwDefaultError({
608
- output,
609
- parsedBody,
610
- errorCode,
611
- });
612
- }
613
- };
614
458
  export const de_AssociateConnectionWithLagCommand = async (output, context) => {
615
459
  if (output.statusCode >= 300) {
616
- return de_AssociateConnectionWithLagCommandError(output, context);
460
+ return de_CommandError(output, context);
617
461
  }
618
462
  const data = await parseBody(output.body, context);
619
463
  let contents = {};
@@ -624,31 +468,9 @@ export const de_AssociateConnectionWithLagCommand = async (output, context) => {
624
468
  };
625
469
  return response;
626
470
  };
627
- const de_AssociateConnectionWithLagCommandError = async (output, context) => {
628
- const parsedOutput = {
629
- ...output,
630
- body: await parseErrorBody(output.body, context),
631
- };
632
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
633
- switch (errorCode) {
634
- case "DirectConnectClientException":
635
- case "com.amazonaws.directconnect#DirectConnectClientException":
636
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
637
- case "DirectConnectServerException":
638
- case "com.amazonaws.directconnect#DirectConnectServerException":
639
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
640
- default:
641
- const parsedBody = parsedOutput.body;
642
- return throwDefaultError({
643
- output,
644
- parsedBody,
645
- errorCode,
646
- });
647
- }
648
- };
649
471
  export const de_AssociateHostedConnectionCommand = async (output, context) => {
650
472
  if (output.statusCode >= 300) {
651
- return de_AssociateHostedConnectionCommandError(output, context);
473
+ return de_CommandError(output, context);
652
474
  }
653
475
  const data = await parseBody(output.body, context);
654
476
  let contents = {};
@@ -659,31 +481,9 @@ export const de_AssociateHostedConnectionCommand = async (output, context) => {
659
481
  };
660
482
  return response;
661
483
  };
662
- const de_AssociateHostedConnectionCommandError = async (output, context) => {
663
- const parsedOutput = {
664
- ...output,
665
- body: await parseErrorBody(output.body, context),
666
- };
667
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
668
- switch (errorCode) {
669
- case "DirectConnectClientException":
670
- case "com.amazonaws.directconnect#DirectConnectClientException":
671
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
672
- case "DirectConnectServerException":
673
- case "com.amazonaws.directconnect#DirectConnectServerException":
674
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
675
- default:
676
- const parsedBody = parsedOutput.body;
677
- return throwDefaultError({
678
- output,
679
- parsedBody,
680
- errorCode,
681
- });
682
- }
683
- };
684
484
  export const de_AssociateMacSecKeyCommand = async (output, context) => {
685
485
  if (output.statusCode >= 300) {
686
- return de_AssociateMacSecKeyCommandError(output, context);
486
+ return de_CommandError(output, context);
687
487
  }
688
488
  const data = await parseBody(output.body, context);
689
489
  let contents = {};
@@ -694,31 +494,9 @@ export const de_AssociateMacSecKeyCommand = async (output, context) => {
694
494
  };
695
495
  return response;
696
496
  };
697
- const de_AssociateMacSecKeyCommandError = async (output, context) => {
698
- const parsedOutput = {
699
- ...output,
700
- body: await parseErrorBody(output.body, context),
701
- };
702
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
703
- switch (errorCode) {
704
- case "DirectConnectClientException":
705
- case "com.amazonaws.directconnect#DirectConnectClientException":
706
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
707
- case "DirectConnectServerException":
708
- case "com.amazonaws.directconnect#DirectConnectServerException":
709
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
710
- default:
711
- const parsedBody = parsedOutput.body;
712
- return throwDefaultError({
713
- output,
714
- parsedBody,
715
- errorCode,
716
- });
717
- }
718
- };
719
497
  export const de_AssociateVirtualInterfaceCommand = async (output, context) => {
720
498
  if (output.statusCode >= 300) {
721
- return de_AssociateVirtualInterfaceCommandError(output, context);
499
+ return de_CommandError(output, context);
722
500
  }
723
501
  const data = await parseBody(output.body, context);
724
502
  let contents = {};
@@ -729,31 +507,9 @@ export const de_AssociateVirtualInterfaceCommand = async (output, context) => {
729
507
  };
730
508
  return response;
731
509
  };
732
- const de_AssociateVirtualInterfaceCommandError = async (output, context) => {
733
- const parsedOutput = {
734
- ...output,
735
- body: await parseErrorBody(output.body, context),
736
- };
737
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
738
- switch (errorCode) {
739
- case "DirectConnectClientException":
740
- case "com.amazonaws.directconnect#DirectConnectClientException":
741
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
742
- case "DirectConnectServerException":
743
- case "com.amazonaws.directconnect#DirectConnectServerException":
744
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
745
- default:
746
- const parsedBody = parsedOutput.body;
747
- return throwDefaultError({
748
- output,
749
- parsedBody,
750
- errorCode,
751
- });
752
- }
753
- };
754
510
  export const de_ConfirmConnectionCommand = async (output, context) => {
755
511
  if (output.statusCode >= 300) {
756
- return de_ConfirmConnectionCommandError(output, context);
512
+ return de_CommandError(output, context);
757
513
  }
758
514
  const data = await parseBody(output.body, context);
759
515
  let contents = {};
@@ -764,31 +520,9 @@ export const de_ConfirmConnectionCommand = async (output, context) => {
764
520
  };
765
521
  return response;
766
522
  };
767
- const de_ConfirmConnectionCommandError = async (output, context) => {
768
- const parsedOutput = {
769
- ...output,
770
- body: await parseErrorBody(output.body, context),
771
- };
772
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
773
- switch (errorCode) {
774
- case "DirectConnectClientException":
775
- case "com.amazonaws.directconnect#DirectConnectClientException":
776
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
777
- case "DirectConnectServerException":
778
- case "com.amazonaws.directconnect#DirectConnectServerException":
779
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
780
- default:
781
- const parsedBody = parsedOutput.body;
782
- return throwDefaultError({
783
- output,
784
- parsedBody,
785
- errorCode,
786
- });
787
- }
788
- };
789
523
  export const de_ConfirmCustomerAgreementCommand = async (output, context) => {
790
524
  if (output.statusCode >= 300) {
791
- return de_ConfirmCustomerAgreementCommandError(output, context);
525
+ return de_CommandError(output, context);
792
526
  }
793
527
  const data = await parseBody(output.body, context);
794
528
  let contents = {};
@@ -799,31 +533,9 @@ export const de_ConfirmCustomerAgreementCommand = async (output, context) => {
799
533
  };
800
534
  return response;
801
535
  };
802
- const de_ConfirmCustomerAgreementCommandError = async (output, context) => {
803
- const parsedOutput = {
804
- ...output,
805
- body: await parseErrorBody(output.body, context),
806
- };
807
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
808
- switch (errorCode) {
809
- case "DirectConnectClientException":
810
- case "com.amazonaws.directconnect#DirectConnectClientException":
811
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
812
- case "DirectConnectServerException":
813
- case "com.amazonaws.directconnect#DirectConnectServerException":
814
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
815
- default:
816
- const parsedBody = parsedOutput.body;
817
- return throwDefaultError({
818
- output,
819
- parsedBody,
820
- errorCode,
821
- });
822
- }
823
- };
824
536
  export const de_ConfirmPrivateVirtualInterfaceCommand = async (output, context) => {
825
537
  if (output.statusCode >= 300) {
826
- return de_ConfirmPrivateVirtualInterfaceCommandError(output, context);
538
+ return de_CommandError(output, context);
827
539
  }
828
540
  const data = await parseBody(output.body, context);
829
541
  let contents = {};
@@ -834,31 +546,9 @@ export const de_ConfirmPrivateVirtualInterfaceCommand = async (output, context)
834
546
  };
835
547
  return response;
836
548
  };
837
- const de_ConfirmPrivateVirtualInterfaceCommandError = async (output, context) => {
838
- const parsedOutput = {
839
- ...output,
840
- body: await parseErrorBody(output.body, context),
841
- };
842
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
843
- switch (errorCode) {
844
- case "DirectConnectClientException":
845
- case "com.amazonaws.directconnect#DirectConnectClientException":
846
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
847
- case "DirectConnectServerException":
848
- case "com.amazonaws.directconnect#DirectConnectServerException":
849
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
850
- default:
851
- const parsedBody = parsedOutput.body;
852
- return throwDefaultError({
853
- output,
854
- parsedBody,
855
- errorCode,
856
- });
857
- }
858
- };
859
549
  export const de_ConfirmPublicVirtualInterfaceCommand = async (output, context) => {
860
550
  if (output.statusCode >= 300) {
861
- return de_ConfirmPublicVirtualInterfaceCommandError(output, context);
551
+ return de_CommandError(output, context);
862
552
  }
863
553
  const data = await parseBody(output.body, context);
864
554
  let contents = {};
@@ -869,31 +559,9 @@ export const de_ConfirmPublicVirtualInterfaceCommand = async (output, context) =
869
559
  };
870
560
  return response;
871
561
  };
872
- const de_ConfirmPublicVirtualInterfaceCommandError = async (output, context) => {
873
- const parsedOutput = {
874
- ...output,
875
- body: await parseErrorBody(output.body, context),
876
- };
877
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
878
- switch (errorCode) {
879
- case "DirectConnectClientException":
880
- case "com.amazonaws.directconnect#DirectConnectClientException":
881
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
882
- case "DirectConnectServerException":
883
- case "com.amazonaws.directconnect#DirectConnectServerException":
884
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
885
- default:
886
- const parsedBody = parsedOutput.body;
887
- return throwDefaultError({
888
- output,
889
- parsedBody,
890
- errorCode,
891
- });
892
- }
893
- };
894
562
  export const de_ConfirmTransitVirtualInterfaceCommand = async (output, context) => {
895
563
  if (output.statusCode >= 300) {
896
- return de_ConfirmTransitVirtualInterfaceCommandError(output, context);
564
+ return de_CommandError(output, context);
897
565
  }
898
566
  const data = await parseBody(output.body, context);
899
567
  let contents = {};
@@ -904,31 +572,9 @@ export const de_ConfirmTransitVirtualInterfaceCommand = async (output, context)
904
572
  };
905
573
  return response;
906
574
  };
907
- const de_ConfirmTransitVirtualInterfaceCommandError = async (output, context) => {
908
- const parsedOutput = {
909
- ...output,
910
- body: await parseErrorBody(output.body, context),
911
- };
912
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
913
- switch (errorCode) {
914
- case "DirectConnectClientException":
915
- case "com.amazonaws.directconnect#DirectConnectClientException":
916
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
917
- case "DirectConnectServerException":
918
- case "com.amazonaws.directconnect#DirectConnectServerException":
919
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
920
- default:
921
- const parsedBody = parsedOutput.body;
922
- return throwDefaultError({
923
- output,
924
- parsedBody,
925
- errorCode,
926
- });
927
- }
928
- };
929
575
  export const de_CreateBGPPeerCommand = async (output, context) => {
930
576
  if (output.statusCode >= 300) {
931
- return de_CreateBGPPeerCommandError(output, context);
577
+ return de_CommandError(output, context);
932
578
  }
933
579
  const data = await parseBody(output.body, context);
934
580
  let contents = {};
@@ -939,31 +585,9 @@ export const de_CreateBGPPeerCommand = async (output, context) => {
939
585
  };
940
586
  return response;
941
587
  };
942
- const de_CreateBGPPeerCommandError = async (output, context) => {
943
- const parsedOutput = {
944
- ...output,
945
- body: await parseErrorBody(output.body, context),
946
- };
947
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
948
- switch (errorCode) {
949
- case "DirectConnectClientException":
950
- case "com.amazonaws.directconnect#DirectConnectClientException":
951
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
952
- case "DirectConnectServerException":
953
- case "com.amazonaws.directconnect#DirectConnectServerException":
954
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
955
- default:
956
- const parsedBody = parsedOutput.body;
957
- return throwDefaultError({
958
- output,
959
- parsedBody,
960
- errorCode,
961
- });
962
- }
963
- };
964
588
  export const de_CreateConnectionCommand = async (output, context) => {
965
589
  if (output.statusCode >= 300) {
966
- return de_CreateConnectionCommandError(output, context);
590
+ return de_CommandError(output, context);
967
591
  }
968
592
  const data = await parseBody(output.body, context);
969
593
  let contents = {};
@@ -974,37 +598,9 @@ export const de_CreateConnectionCommand = async (output, context) => {
974
598
  };
975
599
  return response;
976
600
  };
977
- const de_CreateConnectionCommandError = async (output, context) => {
978
- const parsedOutput = {
979
- ...output,
980
- body: await parseErrorBody(output.body, context),
981
- };
982
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
983
- switch (errorCode) {
984
- case "DirectConnectClientException":
985
- case "com.amazonaws.directconnect#DirectConnectClientException":
986
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
987
- case "DirectConnectServerException":
988
- case "com.amazonaws.directconnect#DirectConnectServerException":
989
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
990
- case "DuplicateTagKeysException":
991
- case "com.amazonaws.directconnect#DuplicateTagKeysException":
992
- throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
993
- case "TooManyTagsException":
994
- case "com.amazonaws.directconnect#TooManyTagsException":
995
- throw await de_TooManyTagsExceptionRes(parsedOutput, context);
996
- default:
997
- const parsedBody = parsedOutput.body;
998
- return throwDefaultError({
999
- output,
1000
- parsedBody,
1001
- errorCode,
1002
- });
1003
- }
1004
- };
1005
601
  export const de_CreateDirectConnectGatewayCommand = async (output, context) => {
1006
602
  if (output.statusCode >= 300) {
1007
- return de_CreateDirectConnectGatewayCommandError(output, context);
603
+ return de_CommandError(output, context);
1008
604
  }
1009
605
  const data = await parseBody(output.body, context);
1010
606
  let contents = {};
@@ -1015,31 +611,9 @@ export const de_CreateDirectConnectGatewayCommand = async (output, context) => {
1015
611
  };
1016
612
  return response;
1017
613
  };
1018
- const de_CreateDirectConnectGatewayCommandError = async (output, context) => {
1019
- const parsedOutput = {
1020
- ...output,
1021
- body: await parseErrorBody(output.body, context),
1022
- };
1023
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1024
- switch (errorCode) {
1025
- case "DirectConnectClientException":
1026
- case "com.amazonaws.directconnect#DirectConnectClientException":
1027
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1028
- case "DirectConnectServerException":
1029
- case "com.amazonaws.directconnect#DirectConnectServerException":
1030
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1031
- default:
1032
- const parsedBody = parsedOutput.body;
1033
- return throwDefaultError({
1034
- output,
1035
- parsedBody,
1036
- errorCode,
1037
- });
1038
- }
1039
- };
1040
614
  export const de_CreateDirectConnectGatewayAssociationCommand = async (output, context) => {
1041
615
  if (output.statusCode >= 300) {
1042
- return de_CreateDirectConnectGatewayAssociationCommandError(output, context);
616
+ return de_CommandError(output, context);
1043
617
  }
1044
618
  const data = await parseBody(output.body, context);
1045
619
  let contents = {};
@@ -1050,31 +624,9 @@ export const de_CreateDirectConnectGatewayAssociationCommand = async (output, co
1050
624
  };
1051
625
  return response;
1052
626
  };
1053
- const de_CreateDirectConnectGatewayAssociationCommandError = async (output, context) => {
1054
- const parsedOutput = {
1055
- ...output,
1056
- body: await parseErrorBody(output.body, context),
1057
- };
1058
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1059
- switch (errorCode) {
1060
- case "DirectConnectClientException":
1061
- case "com.amazonaws.directconnect#DirectConnectClientException":
1062
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1063
- case "DirectConnectServerException":
1064
- case "com.amazonaws.directconnect#DirectConnectServerException":
1065
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1066
- default:
1067
- const parsedBody = parsedOutput.body;
1068
- return throwDefaultError({
1069
- output,
1070
- parsedBody,
1071
- errorCode,
1072
- });
1073
- }
1074
- };
1075
627
  export const de_CreateDirectConnectGatewayAssociationProposalCommand = async (output, context) => {
1076
628
  if (output.statusCode >= 300) {
1077
- return de_CreateDirectConnectGatewayAssociationProposalCommandError(output, context);
629
+ return de_CommandError(output, context);
1078
630
  }
1079
631
  const data = await parseBody(output.body, context);
1080
632
  let contents = {};
@@ -1085,31 +637,9 @@ export const de_CreateDirectConnectGatewayAssociationProposalCommand = async (ou
1085
637
  };
1086
638
  return response;
1087
639
  };
1088
- const de_CreateDirectConnectGatewayAssociationProposalCommandError = async (output, context) => {
1089
- const parsedOutput = {
1090
- ...output,
1091
- body: await parseErrorBody(output.body, context),
1092
- };
1093
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1094
- switch (errorCode) {
1095
- case "DirectConnectClientException":
1096
- case "com.amazonaws.directconnect#DirectConnectClientException":
1097
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1098
- case "DirectConnectServerException":
1099
- case "com.amazonaws.directconnect#DirectConnectServerException":
1100
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1101
- default:
1102
- const parsedBody = parsedOutput.body;
1103
- return throwDefaultError({
1104
- output,
1105
- parsedBody,
1106
- errorCode,
1107
- });
1108
- }
1109
- };
1110
640
  export const de_CreateInterconnectCommand = async (output, context) => {
1111
641
  if (output.statusCode >= 300) {
1112
- return de_CreateInterconnectCommandError(output, context);
642
+ return de_CommandError(output, context);
1113
643
  }
1114
644
  const data = await parseBody(output.body, context);
1115
645
  let contents = {};
@@ -1120,37 +650,9 @@ export const de_CreateInterconnectCommand = async (output, context) => {
1120
650
  };
1121
651
  return response;
1122
652
  };
1123
- const de_CreateInterconnectCommandError = async (output, context) => {
1124
- const parsedOutput = {
1125
- ...output,
1126
- body: await parseErrorBody(output.body, context),
1127
- };
1128
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1129
- switch (errorCode) {
1130
- case "DirectConnectClientException":
1131
- case "com.amazonaws.directconnect#DirectConnectClientException":
1132
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1133
- case "DirectConnectServerException":
1134
- case "com.amazonaws.directconnect#DirectConnectServerException":
1135
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1136
- case "DuplicateTagKeysException":
1137
- case "com.amazonaws.directconnect#DuplicateTagKeysException":
1138
- throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
1139
- case "TooManyTagsException":
1140
- case "com.amazonaws.directconnect#TooManyTagsException":
1141
- throw await de_TooManyTagsExceptionRes(parsedOutput, context);
1142
- default:
1143
- const parsedBody = parsedOutput.body;
1144
- return throwDefaultError({
1145
- output,
1146
- parsedBody,
1147
- errorCode,
1148
- });
1149
- }
1150
- };
1151
653
  export const de_CreateLagCommand = async (output, context) => {
1152
654
  if (output.statusCode >= 300) {
1153
- return de_CreateLagCommandError(output, context);
655
+ return de_CommandError(output, context);
1154
656
  }
1155
657
  const data = await parseBody(output.body, context);
1156
658
  let contents = {};
@@ -1161,37 +663,9 @@ export const de_CreateLagCommand = async (output, context) => {
1161
663
  };
1162
664
  return response;
1163
665
  };
1164
- const de_CreateLagCommandError = async (output, context) => {
1165
- const parsedOutput = {
1166
- ...output,
1167
- body: await parseErrorBody(output.body, context),
1168
- };
1169
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1170
- switch (errorCode) {
1171
- case "DirectConnectClientException":
1172
- case "com.amazonaws.directconnect#DirectConnectClientException":
1173
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1174
- case "DirectConnectServerException":
1175
- case "com.amazonaws.directconnect#DirectConnectServerException":
1176
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1177
- case "DuplicateTagKeysException":
1178
- case "com.amazonaws.directconnect#DuplicateTagKeysException":
1179
- throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
1180
- case "TooManyTagsException":
1181
- case "com.amazonaws.directconnect#TooManyTagsException":
1182
- throw await de_TooManyTagsExceptionRes(parsedOutput, context);
1183
- default:
1184
- const parsedBody = parsedOutput.body;
1185
- return throwDefaultError({
1186
- output,
1187
- parsedBody,
1188
- errorCode,
1189
- });
1190
- }
1191
- };
1192
666
  export const de_CreatePrivateVirtualInterfaceCommand = async (output, context) => {
1193
667
  if (output.statusCode >= 300) {
1194
- return de_CreatePrivateVirtualInterfaceCommandError(output, context);
668
+ return de_CommandError(output, context);
1195
669
  }
1196
670
  const data = await parseBody(output.body, context);
1197
671
  let contents = {};
@@ -1202,37 +676,9 @@ export const de_CreatePrivateVirtualInterfaceCommand = async (output, context) =
1202
676
  };
1203
677
  return response;
1204
678
  };
1205
- const de_CreatePrivateVirtualInterfaceCommandError = async (output, context) => {
1206
- const parsedOutput = {
1207
- ...output,
1208
- body: await parseErrorBody(output.body, context),
1209
- };
1210
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1211
- switch (errorCode) {
1212
- case "DirectConnectClientException":
1213
- case "com.amazonaws.directconnect#DirectConnectClientException":
1214
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1215
- case "DirectConnectServerException":
1216
- case "com.amazonaws.directconnect#DirectConnectServerException":
1217
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1218
- case "DuplicateTagKeysException":
1219
- case "com.amazonaws.directconnect#DuplicateTagKeysException":
1220
- throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
1221
- case "TooManyTagsException":
1222
- case "com.amazonaws.directconnect#TooManyTagsException":
1223
- throw await de_TooManyTagsExceptionRes(parsedOutput, context);
1224
- default:
1225
- const parsedBody = parsedOutput.body;
1226
- return throwDefaultError({
1227
- output,
1228
- parsedBody,
1229
- errorCode,
1230
- });
1231
- }
1232
- };
1233
679
  export const de_CreatePublicVirtualInterfaceCommand = async (output, context) => {
1234
680
  if (output.statusCode >= 300) {
1235
- return de_CreatePublicVirtualInterfaceCommandError(output, context);
681
+ return de_CommandError(output, context);
1236
682
  }
1237
683
  const data = await parseBody(output.body, context);
1238
684
  let contents = {};
@@ -1243,37 +689,9 @@ export const de_CreatePublicVirtualInterfaceCommand = async (output, context) =>
1243
689
  };
1244
690
  return response;
1245
691
  };
1246
- const de_CreatePublicVirtualInterfaceCommandError = async (output, context) => {
1247
- const parsedOutput = {
1248
- ...output,
1249
- body: await parseErrorBody(output.body, context),
1250
- };
1251
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1252
- switch (errorCode) {
1253
- case "DirectConnectClientException":
1254
- case "com.amazonaws.directconnect#DirectConnectClientException":
1255
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1256
- case "DirectConnectServerException":
1257
- case "com.amazonaws.directconnect#DirectConnectServerException":
1258
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1259
- case "DuplicateTagKeysException":
1260
- case "com.amazonaws.directconnect#DuplicateTagKeysException":
1261
- throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
1262
- case "TooManyTagsException":
1263
- case "com.amazonaws.directconnect#TooManyTagsException":
1264
- throw await de_TooManyTagsExceptionRes(parsedOutput, context);
1265
- default:
1266
- const parsedBody = parsedOutput.body;
1267
- return throwDefaultError({
1268
- output,
1269
- parsedBody,
1270
- errorCode,
1271
- });
1272
- }
1273
- };
1274
692
  export const de_CreateTransitVirtualInterfaceCommand = async (output, context) => {
1275
693
  if (output.statusCode >= 300) {
1276
- return de_CreateTransitVirtualInterfaceCommandError(output, context);
694
+ return de_CommandError(output, context);
1277
695
  }
1278
696
  const data = await parseBody(output.body, context);
1279
697
  let contents = {};
@@ -1284,37 +702,9 @@ export const de_CreateTransitVirtualInterfaceCommand = async (output, context) =
1284
702
  };
1285
703
  return response;
1286
704
  };
1287
- const de_CreateTransitVirtualInterfaceCommandError = async (output, context) => {
1288
- const parsedOutput = {
1289
- ...output,
1290
- body: await parseErrorBody(output.body, context),
1291
- };
1292
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1293
- switch (errorCode) {
1294
- case "DirectConnectClientException":
1295
- case "com.amazonaws.directconnect#DirectConnectClientException":
1296
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1297
- case "DirectConnectServerException":
1298
- case "com.amazonaws.directconnect#DirectConnectServerException":
1299
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1300
- case "DuplicateTagKeysException":
1301
- case "com.amazonaws.directconnect#DuplicateTagKeysException":
1302
- throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
1303
- case "TooManyTagsException":
1304
- case "com.amazonaws.directconnect#TooManyTagsException":
1305
- throw await de_TooManyTagsExceptionRes(parsedOutput, context);
1306
- default:
1307
- const parsedBody = parsedOutput.body;
1308
- return throwDefaultError({
1309
- output,
1310
- parsedBody,
1311
- errorCode,
1312
- });
1313
- }
1314
- };
1315
705
  export const de_DeleteBGPPeerCommand = async (output, context) => {
1316
706
  if (output.statusCode >= 300) {
1317
- return de_DeleteBGPPeerCommandError(output, context);
707
+ return de_CommandError(output, context);
1318
708
  }
1319
709
  const data = await parseBody(output.body, context);
1320
710
  let contents = {};
@@ -1325,31 +715,9 @@ export const de_DeleteBGPPeerCommand = async (output, context) => {
1325
715
  };
1326
716
  return response;
1327
717
  };
1328
- const de_DeleteBGPPeerCommandError = async (output, context) => {
1329
- const parsedOutput = {
1330
- ...output,
1331
- body: await parseErrorBody(output.body, context),
1332
- };
1333
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1334
- switch (errorCode) {
1335
- case "DirectConnectClientException":
1336
- case "com.amazonaws.directconnect#DirectConnectClientException":
1337
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1338
- case "DirectConnectServerException":
1339
- case "com.amazonaws.directconnect#DirectConnectServerException":
1340
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1341
- default:
1342
- const parsedBody = parsedOutput.body;
1343
- return throwDefaultError({
1344
- output,
1345
- parsedBody,
1346
- errorCode,
1347
- });
1348
- }
1349
- };
1350
718
  export const de_DeleteConnectionCommand = async (output, context) => {
1351
719
  if (output.statusCode >= 300) {
1352
- return de_DeleteConnectionCommandError(output, context);
720
+ return de_CommandError(output, context);
1353
721
  }
1354
722
  const data = await parseBody(output.body, context);
1355
723
  let contents = {};
@@ -1360,31 +728,9 @@ export const de_DeleteConnectionCommand = async (output, context) => {
1360
728
  };
1361
729
  return response;
1362
730
  };
1363
- const de_DeleteConnectionCommandError = async (output, context) => {
1364
- const parsedOutput = {
1365
- ...output,
1366
- body: await parseErrorBody(output.body, context),
1367
- };
1368
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1369
- switch (errorCode) {
1370
- case "DirectConnectClientException":
1371
- case "com.amazonaws.directconnect#DirectConnectClientException":
1372
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1373
- case "DirectConnectServerException":
1374
- case "com.amazonaws.directconnect#DirectConnectServerException":
1375
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1376
- default:
1377
- const parsedBody = parsedOutput.body;
1378
- return throwDefaultError({
1379
- output,
1380
- parsedBody,
1381
- errorCode,
1382
- });
1383
- }
1384
- };
1385
731
  export const de_DeleteDirectConnectGatewayCommand = async (output, context) => {
1386
732
  if (output.statusCode >= 300) {
1387
- return de_DeleteDirectConnectGatewayCommandError(output, context);
733
+ return de_CommandError(output, context);
1388
734
  }
1389
735
  const data = await parseBody(output.body, context);
1390
736
  let contents = {};
@@ -1395,31 +741,9 @@ export const de_DeleteDirectConnectGatewayCommand = async (output, context) => {
1395
741
  };
1396
742
  return response;
1397
743
  };
1398
- const de_DeleteDirectConnectGatewayCommandError = async (output, context) => {
1399
- const parsedOutput = {
1400
- ...output,
1401
- body: await parseErrorBody(output.body, context),
1402
- };
1403
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1404
- switch (errorCode) {
1405
- case "DirectConnectClientException":
1406
- case "com.amazonaws.directconnect#DirectConnectClientException":
1407
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1408
- case "DirectConnectServerException":
1409
- case "com.amazonaws.directconnect#DirectConnectServerException":
1410
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1411
- default:
1412
- const parsedBody = parsedOutput.body;
1413
- return throwDefaultError({
1414
- output,
1415
- parsedBody,
1416
- errorCode,
1417
- });
1418
- }
1419
- };
1420
744
  export const de_DeleteDirectConnectGatewayAssociationCommand = async (output, context) => {
1421
745
  if (output.statusCode >= 300) {
1422
- return de_DeleteDirectConnectGatewayAssociationCommandError(output, context);
746
+ return de_CommandError(output, context);
1423
747
  }
1424
748
  const data = await parseBody(output.body, context);
1425
749
  let contents = {};
@@ -1430,31 +754,9 @@ export const de_DeleteDirectConnectGatewayAssociationCommand = async (output, co
1430
754
  };
1431
755
  return response;
1432
756
  };
1433
- const de_DeleteDirectConnectGatewayAssociationCommandError = async (output, context) => {
1434
- const parsedOutput = {
1435
- ...output,
1436
- body: await parseErrorBody(output.body, context),
1437
- };
1438
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1439
- switch (errorCode) {
1440
- case "DirectConnectClientException":
1441
- case "com.amazonaws.directconnect#DirectConnectClientException":
1442
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1443
- case "DirectConnectServerException":
1444
- case "com.amazonaws.directconnect#DirectConnectServerException":
1445
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1446
- default:
1447
- const parsedBody = parsedOutput.body;
1448
- return throwDefaultError({
1449
- output,
1450
- parsedBody,
1451
- errorCode,
1452
- });
1453
- }
1454
- };
1455
757
  export const de_DeleteDirectConnectGatewayAssociationProposalCommand = async (output, context) => {
1456
758
  if (output.statusCode >= 300) {
1457
- return de_DeleteDirectConnectGatewayAssociationProposalCommandError(output, context);
759
+ return de_CommandError(output, context);
1458
760
  }
1459
761
  const data = await parseBody(output.body, context);
1460
762
  let contents = {};
@@ -1465,31 +767,9 @@ export const de_DeleteDirectConnectGatewayAssociationProposalCommand = async (ou
1465
767
  };
1466
768
  return response;
1467
769
  };
1468
- const de_DeleteDirectConnectGatewayAssociationProposalCommandError = async (output, context) => {
1469
- const parsedOutput = {
1470
- ...output,
1471
- body: await parseErrorBody(output.body, context),
1472
- };
1473
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1474
- switch (errorCode) {
1475
- case "DirectConnectClientException":
1476
- case "com.amazonaws.directconnect#DirectConnectClientException":
1477
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1478
- case "DirectConnectServerException":
1479
- case "com.amazonaws.directconnect#DirectConnectServerException":
1480
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1481
- default:
1482
- const parsedBody = parsedOutput.body;
1483
- return throwDefaultError({
1484
- output,
1485
- parsedBody,
1486
- errorCode,
1487
- });
1488
- }
1489
- };
1490
770
  export const de_DeleteInterconnectCommand = async (output, context) => {
1491
771
  if (output.statusCode >= 300) {
1492
- return de_DeleteInterconnectCommandError(output, context);
772
+ return de_CommandError(output, context);
1493
773
  }
1494
774
  const data = await parseBody(output.body, context);
1495
775
  let contents = {};
@@ -1500,31 +780,9 @@ export const de_DeleteInterconnectCommand = async (output, context) => {
1500
780
  };
1501
781
  return response;
1502
782
  };
1503
- const de_DeleteInterconnectCommandError = async (output, context) => {
1504
- const parsedOutput = {
1505
- ...output,
1506
- body: await parseErrorBody(output.body, context),
1507
- };
1508
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1509
- switch (errorCode) {
1510
- case "DirectConnectClientException":
1511
- case "com.amazonaws.directconnect#DirectConnectClientException":
1512
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1513
- case "DirectConnectServerException":
1514
- case "com.amazonaws.directconnect#DirectConnectServerException":
1515
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1516
- default:
1517
- const parsedBody = parsedOutput.body;
1518
- return throwDefaultError({
1519
- output,
1520
- parsedBody,
1521
- errorCode,
1522
- });
1523
- }
1524
- };
1525
783
  export const de_DeleteLagCommand = async (output, context) => {
1526
784
  if (output.statusCode >= 300) {
1527
- return de_DeleteLagCommandError(output, context);
785
+ return de_CommandError(output, context);
1528
786
  }
1529
787
  const data = await parseBody(output.body, context);
1530
788
  let contents = {};
@@ -1535,31 +793,9 @@ export const de_DeleteLagCommand = async (output, context) => {
1535
793
  };
1536
794
  return response;
1537
795
  };
1538
- const de_DeleteLagCommandError = async (output, context) => {
1539
- const parsedOutput = {
1540
- ...output,
1541
- body: await parseErrorBody(output.body, context),
1542
- };
1543
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1544
- switch (errorCode) {
1545
- case "DirectConnectClientException":
1546
- case "com.amazonaws.directconnect#DirectConnectClientException":
1547
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1548
- case "DirectConnectServerException":
1549
- case "com.amazonaws.directconnect#DirectConnectServerException":
1550
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1551
- default:
1552
- const parsedBody = parsedOutput.body;
1553
- return throwDefaultError({
1554
- output,
1555
- parsedBody,
1556
- errorCode,
1557
- });
1558
- }
1559
- };
1560
796
  export const de_DeleteVirtualInterfaceCommand = async (output, context) => {
1561
797
  if (output.statusCode >= 300) {
1562
- return de_DeleteVirtualInterfaceCommandError(output, context);
798
+ return de_CommandError(output, context);
1563
799
  }
1564
800
  const data = await parseBody(output.body, context);
1565
801
  let contents = {};
@@ -1570,31 +806,9 @@ export const de_DeleteVirtualInterfaceCommand = async (output, context) => {
1570
806
  };
1571
807
  return response;
1572
808
  };
1573
- const de_DeleteVirtualInterfaceCommandError = async (output, context) => {
1574
- const parsedOutput = {
1575
- ...output,
1576
- body: await parseErrorBody(output.body, context),
1577
- };
1578
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1579
- switch (errorCode) {
1580
- case "DirectConnectClientException":
1581
- case "com.amazonaws.directconnect#DirectConnectClientException":
1582
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1583
- case "DirectConnectServerException":
1584
- case "com.amazonaws.directconnect#DirectConnectServerException":
1585
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1586
- default:
1587
- const parsedBody = parsedOutput.body;
1588
- return throwDefaultError({
1589
- output,
1590
- parsedBody,
1591
- errorCode,
1592
- });
1593
- }
1594
- };
1595
809
  export const de_DescribeConnectionLoaCommand = async (output, context) => {
1596
810
  if (output.statusCode >= 300) {
1597
- return de_DescribeConnectionLoaCommandError(output, context);
811
+ return de_CommandError(output, context);
1598
812
  }
1599
813
  const data = await parseBody(output.body, context);
1600
814
  let contents = {};
@@ -1605,66 +819,22 @@ export const de_DescribeConnectionLoaCommand = async (output, context) => {
1605
819
  };
1606
820
  return response;
1607
821
  };
1608
- const de_DescribeConnectionLoaCommandError = async (output, context) => {
1609
- const parsedOutput = {
1610
- ...output,
1611
- body: await parseErrorBody(output.body, context),
1612
- };
1613
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1614
- switch (errorCode) {
1615
- case "DirectConnectClientException":
1616
- case "com.amazonaws.directconnect#DirectConnectClientException":
1617
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1618
- case "DirectConnectServerException":
1619
- case "com.amazonaws.directconnect#DirectConnectServerException":
1620
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1621
- default:
1622
- const parsedBody = parsedOutput.body;
1623
- return throwDefaultError({
1624
- output,
1625
- parsedBody,
1626
- errorCode,
1627
- });
1628
- }
1629
- };
1630
- export const de_DescribeConnectionsCommand = async (output, context) => {
1631
- if (output.statusCode >= 300) {
1632
- return de_DescribeConnectionsCommandError(output, context);
1633
- }
1634
- const data = await parseBody(output.body, context);
1635
- let contents = {};
1636
- contents = de_Connections(data, context);
1637
- const response = {
1638
- $metadata: deserializeMetadata(output),
1639
- ...contents,
822
+ export const de_DescribeConnectionsCommand = async (output, context) => {
823
+ if (output.statusCode >= 300) {
824
+ return de_CommandError(output, context);
825
+ }
826
+ const data = await parseBody(output.body, context);
827
+ let contents = {};
828
+ contents = de_Connections(data, context);
829
+ const response = {
830
+ $metadata: deserializeMetadata(output),
831
+ ...contents,
1640
832
  };
1641
833
  return response;
1642
834
  };
1643
- const de_DescribeConnectionsCommandError = async (output, context) => {
1644
- const parsedOutput = {
1645
- ...output,
1646
- body: await parseErrorBody(output.body, context),
1647
- };
1648
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1649
- switch (errorCode) {
1650
- case "DirectConnectClientException":
1651
- case "com.amazonaws.directconnect#DirectConnectClientException":
1652
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1653
- case "DirectConnectServerException":
1654
- case "com.amazonaws.directconnect#DirectConnectServerException":
1655
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1656
- default:
1657
- const parsedBody = parsedOutput.body;
1658
- return throwDefaultError({
1659
- output,
1660
- parsedBody,
1661
- errorCode,
1662
- });
1663
- }
1664
- };
1665
835
  export const de_DescribeConnectionsOnInterconnectCommand = async (output, context) => {
1666
836
  if (output.statusCode >= 300) {
1667
- return de_DescribeConnectionsOnInterconnectCommandError(output, context);
837
+ return de_CommandError(output, context);
1668
838
  }
1669
839
  const data = await parseBody(output.body, context);
1670
840
  let contents = {};
@@ -1675,31 +845,9 @@ export const de_DescribeConnectionsOnInterconnectCommand = async (output, contex
1675
845
  };
1676
846
  return response;
1677
847
  };
1678
- const de_DescribeConnectionsOnInterconnectCommandError = async (output, context) => {
1679
- const parsedOutput = {
1680
- ...output,
1681
- body: await parseErrorBody(output.body, context),
1682
- };
1683
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1684
- switch (errorCode) {
1685
- case "DirectConnectClientException":
1686
- case "com.amazonaws.directconnect#DirectConnectClientException":
1687
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1688
- case "DirectConnectServerException":
1689
- case "com.amazonaws.directconnect#DirectConnectServerException":
1690
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1691
- default:
1692
- const parsedBody = parsedOutput.body;
1693
- return throwDefaultError({
1694
- output,
1695
- parsedBody,
1696
- errorCode,
1697
- });
1698
- }
1699
- };
1700
848
  export const de_DescribeCustomerMetadataCommand = async (output, context) => {
1701
849
  if (output.statusCode >= 300) {
1702
- return de_DescribeCustomerMetadataCommandError(output, context);
850
+ return de_CommandError(output, context);
1703
851
  }
1704
852
  const data = await parseBody(output.body, context);
1705
853
  let contents = {};
@@ -1710,31 +858,9 @@ export const de_DescribeCustomerMetadataCommand = async (output, context) => {
1710
858
  };
1711
859
  return response;
1712
860
  };
1713
- const de_DescribeCustomerMetadataCommandError = async (output, context) => {
1714
- const parsedOutput = {
1715
- ...output,
1716
- body: await parseErrorBody(output.body, context),
1717
- };
1718
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1719
- switch (errorCode) {
1720
- case "DirectConnectClientException":
1721
- case "com.amazonaws.directconnect#DirectConnectClientException":
1722
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1723
- case "DirectConnectServerException":
1724
- case "com.amazonaws.directconnect#DirectConnectServerException":
1725
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1726
- default:
1727
- const parsedBody = parsedOutput.body;
1728
- return throwDefaultError({
1729
- output,
1730
- parsedBody,
1731
- errorCode,
1732
- });
1733
- }
1734
- };
1735
861
  export const de_DescribeDirectConnectGatewayAssociationProposalsCommand = async (output, context) => {
1736
862
  if (output.statusCode >= 300) {
1737
- return de_DescribeDirectConnectGatewayAssociationProposalsCommandError(output, context);
863
+ return de_CommandError(output, context);
1738
864
  }
1739
865
  const data = await parseBody(output.body, context);
1740
866
  let contents = {};
@@ -1745,31 +871,9 @@ export const de_DescribeDirectConnectGatewayAssociationProposalsCommand = async
1745
871
  };
1746
872
  return response;
1747
873
  };
1748
- const de_DescribeDirectConnectGatewayAssociationProposalsCommandError = async (output, context) => {
1749
- const parsedOutput = {
1750
- ...output,
1751
- body: await parseErrorBody(output.body, context),
1752
- };
1753
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1754
- switch (errorCode) {
1755
- case "DirectConnectClientException":
1756
- case "com.amazonaws.directconnect#DirectConnectClientException":
1757
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1758
- case "DirectConnectServerException":
1759
- case "com.amazonaws.directconnect#DirectConnectServerException":
1760
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1761
- default:
1762
- const parsedBody = parsedOutput.body;
1763
- return throwDefaultError({
1764
- output,
1765
- parsedBody,
1766
- errorCode,
1767
- });
1768
- }
1769
- };
1770
874
  export const de_DescribeDirectConnectGatewayAssociationsCommand = async (output, context) => {
1771
875
  if (output.statusCode >= 300) {
1772
- return de_DescribeDirectConnectGatewayAssociationsCommandError(output, context);
876
+ return de_CommandError(output, context);
1773
877
  }
1774
878
  const data = await parseBody(output.body, context);
1775
879
  let contents = {};
@@ -1780,31 +884,9 @@ export const de_DescribeDirectConnectGatewayAssociationsCommand = async (output,
1780
884
  };
1781
885
  return response;
1782
886
  };
1783
- const de_DescribeDirectConnectGatewayAssociationsCommandError = async (output, context) => {
1784
- const parsedOutput = {
1785
- ...output,
1786
- body: await parseErrorBody(output.body, context),
1787
- };
1788
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1789
- switch (errorCode) {
1790
- case "DirectConnectClientException":
1791
- case "com.amazonaws.directconnect#DirectConnectClientException":
1792
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1793
- case "DirectConnectServerException":
1794
- case "com.amazonaws.directconnect#DirectConnectServerException":
1795
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1796
- default:
1797
- const parsedBody = parsedOutput.body;
1798
- return throwDefaultError({
1799
- output,
1800
- parsedBody,
1801
- errorCode,
1802
- });
1803
- }
1804
- };
1805
887
  export const de_DescribeDirectConnectGatewayAttachmentsCommand = async (output, context) => {
1806
888
  if (output.statusCode >= 300) {
1807
- return de_DescribeDirectConnectGatewayAttachmentsCommandError(output, context);
889
+ return de_CommandError(output, context);
1808
890
  }
1809
891
  const data = await parseBody(output.body, context);
1810
892
  let contents = {};
@@ -1815,31 +897,9 @@ export const de_DescribeDirectConnectGatewayAttachmentsCommand = async (output,
1815
897
  };
1816
898
  return response;
1817
899
  };
1818
- const de_DescribeDirectConnectGatewayAttachmentsCommandError = async (output, context) => {
1819
- const parsedOutput = {
1820
- ...output,
1821
- body: await parseErrorBody(output.body, context),
1822
- };
1823
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1824
- switch (errorCode) {
1825
- case "DirectConnectClientException":
1826
- case "com.amazonaws.directconnect#DirectConnectClientException":
1827
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1828
- case "DirectConnectServerException":
1829
- case "com.amazonaws.directconnect#DirectConnectServerException":
1830
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1831
- default:
1832
- const parsedBody = parsedOutput.body;
1833
- return throwDefaultError({
1834
- output,
1835
- parsedBody,
1836
- errorCode,
1837
- });
1838
- }
1839
- };
1840
900
  export const de_DescribeDirectConnectGatewaysCommand = async (output, context) => {
1841
901
  if (output.statusCode >= 300) {
1842
- return de_DescribeDirectConnectGatewaysCommandError(output, context);
902
+ return de_CommandError(output, context);
1843
903
  }
1844
904
  const data = await parseBody(output.body, context);
1845
905
  let contents = {};
@@ -1850,31 +910,9 @@ export const de_DescribeDirectConnectGatewaysCommand = async (output, context) =
1850
910
  };
1851
911
  return response;
1852
912
  };
1853
- const de_DescribeDirectConnectGatewaysCommandError = async (output, context) => {
1854
- const parsedOutput = {
1855
- ...output,
1856
- body: await parseErrorBody(output.body, context),
1857
- };
1858
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1859
- switch (errorCode) {
1860
- case "DirectConnectClientException":
1861
- case "com.amazonaws.directconnect#DirectConnectClientException":
1862
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1863
- case "DirectConnectServerException":
1864
- case "com.amazonaws.directconnect#DirectConnectServerException":
1865
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1866
- default:
1867
- const parsedBody = parsedOutput.body;
1868
- return throwDefaultError({
1869
- output,
1870
- parsedBody,
1871
- errorCode,
1872
- });
1873
- }
1874
- };
1875
913
  export const de_DescribeHostedConnectionsCommand = async (output, context) => {
1876
914
  if (output.statusCode >= 300) {
1877
- return de_DescribeHostedConnectionsCommandError(output, context);
915
+ return de_CommandError(output, context);
1878
916
  }
1879
917
  const data = await parseBody(output.body, context);
1880
918
  let contents = {};
@@ -1885,31 +923,9 @@ export const de_DescribeHostedConnectionsCommand = async (output, context) => {
1885
923
  };
1886
924
  return response;
1887
925
  };
1888
- const de_DescribeHostedConnectionsCommandError = async (output, context) => {
1889
- const parsedOutput = {
1890
- ...output,
1891
- body: await parseErrorBody(output.body, context),
1892
- };
1893
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1894
- switch (errorCode) {
1895
- case "DirectConnectClientException":
1896
- case "com.amazonaws.directconnect#DirectConnectClientException":
1897
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1898
- case "DirectConnectServerException":
1899
- case "com.amazonaws.directconnect#DirectConnectServerException":
1900
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1901
- default:
1902
- const parsedBody = parsedOutput.body;
1903
- return throwDefaultError({
1904
- output,
1905
- parsedBody,
1906
- errorCode,
1907
- });
1908
- }
1909
- };
1910
926
  export const de_DescribeInterconnectLoaCommand = async (output, context) => {
1911
927
  if (output.statusCode >= 300) {
1912
- return de_DescribeInterconnectLoaCommandError(output, context);
928
+ return de_CommandError(output, context);
1913
929
  }
1914
930
  const data = await parseBody(output.body, context);
1915
931
  let contents = {};
@@ -1920,31 +936,9 @@ export const de_DescribeInterconnectLoaCommand = async (output, context) => {
1920
936
  };
1921
937
  return response;
1922
938
  };
1923
- const de_DescribeInterconnectLoaCommandError = async (output, context) => {
1924
- const parsedOutput = {
1925
- ...output,
1926
- body: await parseErrorBody(output.body, context),
1927
- };
1928
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1929
- switch (errorCode) {
1930
- case "DirectConnectClientException":
1931
- case "com.amazonaws.directconnect#DirectConnectClientException":
1932
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1933
- case "DirectConnectServerException":
1934
- case "com.amazonaws.directconnect#DirectConnectServerException":
1935
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1936
- default:
1937
- const parsedBody = parsedOutput.body;
1938
- return throwDefaultError({
1939
- output,
1940
- parsedBody,
1941
- errorCode,
1942
- });
1943
- }
1944
- };
1945
939
  export const de_DescribeInterconnectsCommand = async (output, context) => {
1946
940
  if (output.statusCode >= 300) {
1947
- return de_DescribeInterconnectsCommandError(output, context);
941
+ return de_CommandError(output, context);
1948
942
  }
1949
943
  const data = await parseBody(output.body, context);
1950
944
  let contents = {};
@@ -1955,31 +949,9 @@ export const de_DescribeInterconnectsCommand = async (output, context) => {
1955
949
  };
1956
950
  return response;
1957
951
  };
1958
- const de_DescribeInterconnectsCommandError = async (output, context) => {
1959
- const parsedOutput = {
1960
- ...output,
1961
- body: await parseErrorBody(output.body, context),
1962
- };
1963
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1964
- switch (errorCode) {
1965
- case "DirectConnectClientException":
1966
- case "com.amazonaws.directconnect#DirectConnectClientException":
1967
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
1968
- case "DirectConnectServerException":
1969
- case "com.amazonaws.directconnect#DirectConnectServerException":
1970
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1971
- default:
1972
- const parsedBody = parsedOutput.body;
1973
- return throwDefaultError({
1974
- output,
1975
- parsedBody,
1976
- errorCode,
1977
- });
1978
- }
1979
- };
1980
952
  export const de_DescribeLagsCommand = async (output, context) => {
1981
953
  if (output.statusCode >= 300) {
1982
- return de_DescribeLagsCommandError(output, context);
954
+ return de_CommandError(output, context);
1983
955
  }
1984
956
  const data = await parseBody(output.body, context);
1985
957
  let contents = {};
@@ -1990,31 +962,9 @@ export const de_DescribeLagsCommand = async (output, context) => {
1990
962
  };
1991
963
  return response;
1992
964
  };
1993
- const de_DescribeLagsCommandError = async (output, context) => {
1994
- const parsedOutput = {
1995
- ...output,
1996
- body: await parseErrorBody(output.body, context),
1997
- };
1998
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1999
- switch (errorCode) {
2000
- case "DirectConnectClientException":
2001
- case "com.amazonaws.directconnect#DirectConnectClientException":
2002
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
2003
- case "DirectConnectServerException":
2004
- case "com.amazonaws.directconnect#DirectConnectServerException":
2005
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
2006
- default:
2007
- const parsedBody = parsedOutput.body;
2008
- return throwDefaultError({
2009
- output,
2010
- parsedBody,
2011
- errorCode,
2012
- });
2013
- }
2014
- };
2015
965
  export const de_DescribeLoaCommand = async (output, context) => {
2016
966
  if (output.statusCode >= 300) {
2017
- return de_DescribeLoaCommandError(output, context);
967
+ return de_CommandError(output, context);
2018
968
  }
2019
969
  const data = await parseBody(output.body, context);
2020
970
  let contents = {};
@@ -2025,31 +975,9 @@ export const de_DescribeLoaCommand = async (output, context) => {
2025
975
  };
2026
976
  return response;
2027
977
  };
2028
- const de_DescribeLoaCommandError = async (output, context) => {
2029
- const parsedOutput = {
2030
- ...output,
2031
- body: await parseErrorBody(output.body, context),
2032
- };
2033
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2034
- switch (errorCode) {
2035
- case "DirectConnectClientException":
2036
- case "com.amazonaws.directconnect#DirectConnectClientException":
2037
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
2038
- case "DirectConnectServerException":
2039
- case "com.amazonaws.directconnect#DirectConnectServerException":
2040
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
2041
- default:
2042
- const parsedBody = parsedOutput.body;
2043
- return throwDefaultError({
2044
- output,
2045
- parsedBody,
2046
- errorCode,
2047
- });
2048
- }
2049
- };
2050
978
  export const de_DescribeLocationsCommand = async (output, context) => {
2051
979
  if (output.statusCode >= 300) {
2052
- return de_DescribeLocationsCommandError(output, context);
980
+ return de_CommandError(output, context);
2053
981
  }
2054
982
  const data = await parseBody(output.body, context);
2055
983
  let contents = {};
@@ -2060,31 +988,9 @@ export const de_DescribeLocationsCommand = async (output, context) => {
2060
988
  };
2061
989
  return response;
2062
990
  };
2063
- const de_DescribeLocationsCommandError = async (output, context) => {
2064
- const parsedOutput = {
2065
- ...output,
2066
- body: await parseErrorBody(output.body, context),
2067
- };
2068
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2069
- switch (errorCode) {
2070
- case "DirectConnectClientException":
2071
- case "com.amazonaws.directconnect#DirectConnectClientException":
2072
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
2073
- case "DirectConnectServerException":
2074
- case "com.amazonaws.directconnect#DirectConnectServerException":
2075
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
2076
- default:
2077
- const parsedBody = parsedOutput.body;
2078
- return throwDefaultError({
2079
- output,
2080
- parsedBody,
2081
- errorCode,
2082
- });
2083
- }
2084
- };
2085
991
  export const de_DescribeRouterConfigurationCommand = async (output, context) => {
2086
992
  if (output.statusCode >= 300) {
2087
- return de_DescribeRouterConfigurationCommandError(output, context);
993
+ return de_CommandError(output, context);
2088
994
  }
2089
995
  const data = await parseBody(output.body, context);
2090
996
  let contents = {};
@@ -2095,31 +1001,9 @@ export const de_DescribeRouterConfigurationCommand = async (output, context) =>
2095
1001
  };
2096
1002
  return response;
2097
1003
  };
2098
- const de_DescribeRouterConfigurationCommandError = async (output, context) => {
2099
- const parsedOutput = {
2100
- ...output,
2101
- body: await parseErrorBody(output.body, context),
2102
- };
2103
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2104
- switch (errorCode) {
2105
- case "DirectConnectClientException":
2106
- case "com.amazonaws.directconnect#DirectConnectClientException":
2107
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
2108
- case "DirectConnectServerException":
2109
- case "com.amazonaws.directconnect#DirectConnectServerException":
2110
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
2111
- default:
2112
- const parsedBody = parsedOutput.body;
2113
- return throwDefaultError({
2114
- output,
2115
- parsedBody,
2116
- errorCode,
2117
- });
2118
- }
2119
- };
2120
1004
  export const de_DescribeTagsCommand = async (output, context) => {
2121
1005
  if (output.statusCode >= 300) {
2122
- return de_DescribeTagsCommandError(output, context);
1006
+ return de_CommandError(output, context);
2123
1007
  }
2124
1008
  const data = await parseBody(output.body, context);
2125
1009
  let contents = {};
@@ -2130,66 +1014,9 @@ export const de_DescribeTagsCommand = async (output, context) => {
2130
1014
  };
2131
1015
  return response;
2132
1016
  };
2133
- const de_DescribeTagsCommandError = async (output, context) => {
2134
- const parsedOutput = {
2135
- ...output,
2136
- body: await parseErrorBody(output.body, context),
2137
- };
2138
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2139
- switch (errorCode) {
2140
- case "DirectConnectClientException":
2141
- case "com.amazonaws.directconnect#DirectConnectClientException":
2142
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
2143
- case "DirectConnectServerException":
2144
- case "com.amazonaws.directconnect#DirectConnectServerException":
2145
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
2146
- default:
2147
- const parsedBody = parsedOutput.body;
2148
- return throwDefaultError({
2149
- output,
2150
- parsedBody,
2151
- errorCode,
2152
- });
2153
- }
2154
- };
2155
1017
  export const de_DescribeVirtualGatewaysCommand = async (output, context) => {
2156
1018
  if (output.statusCode >= 300) {
2157
- return de_DescribeVirtualGatewaysCommandError(output, context);
2158
- }
2159
- const data = await parseBody(output.body, context);
2160
- let contents = {};
2161
- contents = _json(data);
2162
- const response = {
2163
- $metadata: deserializeMetadata(output),
2164
- ...contents,
2165
- };
2166
- return response;
2167
- };
2168
- const de_DescribeVirtualGatewaysCommandError = async (output, context) => {
2169
- const parsedOutput = {
2170
- ...output,
2171
- body: await parseErrorBody(output.body, context),
2172
- };
2173
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2174
- switch (errorCode) {
2175
- case "DirectConnectClientException":
2176
- case "com.amazonaws.directconnect#DirectConnectClientException":
2177
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
2178
- case "DirectConnectServerException":
2179
- case "com.amazonaws.directconnect#DirectConnectServerException":
2180
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
2181
- default:
2182
- const parsedBody = parsedOutput.body;
2183
- return throwDefaultError({
2184
- output,
2185
- parsedBody,
2186
- errorCode,
2187
- });
2188
- }
2189
- };
2190
- export const de_DescribeVirtualInterfacesCommand = async (output, context) => {
2191
- if (output.statusCode >= 300) {
2192
- return de_DescribeVirtualInterfacesCommandError(output, context);
1019
+ return de_CommandError(output, context);
2193
1020
  }
2194
1021
  const data = await parseBody(output.body, context);
2195
1022
  let contents = {};
@@ -2197,34 +1024,25 @@ export const de_DescribeVirtualInterfacesCommand = async (output, context) => {
2197
1024
  const response = {
2198
1025
  $metadata: deserializeMetadata(output),
2199
1026
  ...contents,
2200
- };
2201
- return response;
2202
- };
2203
- const de_DescribeVirtualInterfacesCommandError = async (output, context) => {
2204
- const parsedOutput = {
2205
- ...output,
2206
- body: await parseErrorBody(output.body, context),
2207
- };
2208
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2209
- switch (errorCode) {
2210
- case "DirectConnectClientException":
2211
- case "com.amazonaws.directconnect#DirectConnectClientException":
2212
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
2213
- case "DirectConnectServerException":
2214
- case "com.amazonaws.directconnect#DirectConnectServerException":
2215
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
2216
- default:
2217
- const parsedBody = parsedOutput.body;
2218
- return throwDefaultError({
2219
- output,
2220
- parsedBody,
2221
- errorCode,
2222
- });
1027
+ };
1028
+ return response;
1029
+ };
1030
+ export const de_DescribeVirtualInterfacesCommand = async (output, context) => {
1031
+ if (output.statusCode >= 300) {
1032
+ return de_CommandError(output, context);
2223
1033
  }
1034
+ const data = await parseBody(output.body, context);
1035
+ let contents = {};
1036
+ contents = _json(data);
1037
+ const response = {
1038
+ $metadata: deserializeMetadata(output),
1039
+ ...contents,
1040
+ };
1041
+ return response;
2224
1042
  };
2225
1043
  export const de_DisassociateConnectionFromLagCommand = async (output, context) => {
2226
1044
  if (output.statusCode >= 300) {
2227
- return de_DisassociateConnectionFromLagCommandError(output, context);
1045
+ return de_CommandError(output, context);
2228
1046
  }
2229
1047
  const data = await parseBody(output.body, context);
2230
1048
  let contents = {};
@@ -2235,31 +1053,9 @@ export const de_DisassociateConnectionFromLagCommand = async (output, context) =
2235
1053
  };
2236
1054
  return response;
2237
1055
  };
2238
- const de_DisassociateConnectionFromLagCommandError = async (output, context) => {
2239
- const parsedOutput = {
2240
- ...output,
2241
- body: await parseErrorBody(output.body, context),
2242
- };
2243
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2244
- switch (errorCode) {
2245
- case "DirectConnectClientException":
2246
- case "com.amazonaws.directconnect#DirectConnectClientException":
2247
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
2248
- case "DirectConnectServerException":
2249
- case "com.amazonaws.directconnect#DirectConnectServerException":
2250
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
2251
- default:
2252
- const parsedBody = parsedOutput.body;
2253
- return throwDefaultError({
2254
- output,
2255
- parsedBody,
2256
- errorCode,
2257
- });
2258
- }
2259
- };
2260
1056
  export const de_DisassociateMacSecKeyCommand = async (output, context) => {
2261
1057
  if (output.statusCode >= 300) {
2262
- return de_DisassociateMacSecKeyCommandError(output, context);
1058
+ return de_CommandError(output, context);
2263
1059
  }
2264
1060
  const data = await parseBody(output.body, context);
2265
1061
  let contents = {};
@@ -2270,31 +1066,9 @@ export const de_DisassociateMacSecKeyCommand = async (output, context) => {
2270
1066
  };
2271
1067
  return response;
2272
1068
  };
2273
- const de_DisassociateMacSecKeyCommandError = async (output, context) => {
2274
- const parsedOutput = {
2275
- ...output,
2276
- body: await parseErrorBody(output.body, context),
2277
- };
2278
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2279
- switch (errorCode) {
2280
- case "DirectConnectClientException":
2281
- case "com.amazonaws.directconnect#DirectConnectClientException":
2282
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
2283
- case "DirectConnectServerException":
2284
- case "com.amazonaws.directconnect#DirectConnectServerException":
2285
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
2286
- default:
2287
- const parsedBody = parsedOutput.body;
2288
- return throwDefaultError({
2289
- output,
2290
- parsedBody,
2291
- errorCode,
2292
- });
2293
- }
2294
- };
2295
1069
  export const de_ListVirtualInterfaceTestHistoryCommand = async (output, context) => {
2296
1070
  if (output.statusCode >= 300) {
2297
- return de_ListVirtualInterfaceTestHistoryCommandError(output, context);
1071
+ return de_CommandError(output, context);
2298
1072
  }
2299
1073
  const data = await parseBody(output.body, context);
2300
1074
  let contents = {};
@@ -2305,31 +1079,9 @@ export const de_ListVirtualInterfaceTestHistoryCommand = async (output, context)
2305
1079
  };
2306
1080
  return response;
2307
1081
  };
2308
- const de_ListVirtualInterfaceTestHistoryCommandError = async (output, context) => {
2309
- const parsedOutput = {
2310
- ...output,
2311
- body: await parseErrorBody(output.body, context),
2312
- };
2313
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2314
- switch (errorCode) {
2315
- case "DirectConnectClientException":
2316
- case "com.amazonaws.directconnect#DirectConnectClientException":
2317
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
2318
- case "DirectConnectServerException":
2319
- case "com.amazonaws.directconnect#DirectConnectServerException":
2320
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
2321
- default:
2322
- const parsedBody = parsedOutput.body;
2323
- return throwDefaultError({
2324
- output,
2325
- parsedBody,
2326
- errorCode,
2327
- });
2328
- }
2329
- };
2330
1082
  export const de_StartBgpFailoverTestCommand = async (output, context) => {
2331
1083
  if (output.statusCode >= 300) {
2332
- return de_StartBgpFailoverTestCommandError(output, context);
1084
+ return de_CommandError(output, context);
2333
1085
  }
2334
1086
  const data = await parseBody(output.body, context);
2335
1087
  let contents = {};
@@ -2340,31 +1092,9 @@ export const de_StartBgpFailoverTestCommand = async (output, context) => {
2340
1092
  };
2341
1093
  return response;
2342
1094
  };
2343
- const de_StartBgpFailoverTestCommandError = async (output, context) => {
2344
- const parsedOutput = {
2345
- ...output,
2346
- body: await parseErrorBody(output.body, context),
2347
- };
2348
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2349
- switch (errorCode) {
2350
- case "DirectConnectClientException":
2351
- case "com.amazonaws.directconnect#DirectConnectClientException":
2352
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
2353
- case "DirectConnectServerException":
2354
- case "com.amazonaws.directconnect#DirectConnectServerException":
2355
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
2356
- default:
2357
- const parsedBody = parsedOutput.body;
2358
- return throwDefaultError({
2359
- output,
2360
- parsedBody,
2361
- errorCode,
2362
- });
2363
- }
2364
- };
2365
1095
  export const de_StopBgpFailoverTestCommand = async (output, context) => {
2366
1096
  if (output.statusCode >= 300) {
2367
- return de_StopBgpFailoverTestCommandError(output, context);
1097
+ return de_CommandError(output, context);
2368
1098
  }
2369
1099
  const data = await parseBody(output.body, context);
2370
1100
  let contents = {};
@@ -2375,31 +1105,9 @@ export const de_StopBgpFailoverTestCommand = async (output, context) => {
2375
1105
  };
2376
1106
  return response;
2377
1107
  };
2378
- const de_StopBgpFailoverTestCommandError = async (output, context) => {
2379
- const parsedOutput = {
2380
- ...output,
2381
- body: await parseErrorBody(output.body, context),
2382
- };
2383
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2384
- switch (errorCode) {
2385
- case "DirectConnectClientException":
2386
- case "com.amazonaws.directconnect#DirectConnectClientException":
2387
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
2388
- case "DirectConnectServerException":
2389
- case "com.amazonaws.directconnect#DirectConnectServerException":
2390
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
2391
- default:
2392
- const parsedBody = parsedOutput.body;
2393
- return throwDefaultError({
2394
- output,
2395
- parsedBody,
2396
- errorCode,
2397
- });
2398
- }
2399
- };
2400
1108
  export const de_TagResourceCommand = async (output, context) => {
2401
1109
  if (output.statusCode >= 300) {
2402
- return de_TagResourceCommandError(output, context);
1110
+ return de_CommandError(output, context);
2403
1111
  }
2404
1112
  const data = await parseBody(output.body, context);
2405
1113
  let contents = {};
@@ -2410,37 +1118,9 @@ export const de_TagResourceCommand = async (output, context) => {
2410
1118
  };
2411
1119
  return response;
2412
1120
  };
2413
- const de_TagResourceCommandError = async (output, context) => {
2414
- const parsedOutput = {
2415
- ...output,
2416
- body: await parseErrorBody(output.body, context),
2417
- };
2418
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2419
- switch (errorCode) {
2420
- case "DirectConnectClientException":
2421
- case "com.amazonaws.directconnect#DirectConnectClientException":
2422
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
2423
- case "DirectConnectServerException":
2424
- case "com.amazonaws.directconnect#DirectConnectServerException":
2425
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
2426
- case "DuplicateTagKeysException":
2427
- case "com.amazonaws.directconnect#DuplicateTagKeysException":
2428
- throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
2429
- case "TooManyTagsException":
2430
- case "com.amazonaws.directconnect#TooManyTagsException":
2431
- throw await de_TooManyTagsExceptionRes(parsedOutput, context);
2432
- default:
2433
- const parsedBody = parsedOutput.body;
2434
- return throwDefaultError({
2435
- output,
2436
- parsedBody,
2437
- errorCode,
2438
- });
2439
- }
2440
- };
2441
1121
  export const de_UntagResourceCommand = async (output, context) => {
2442
1122
  if (output.statusCode >= 300) {
2443
- return de_UntagResourceCommandError(output, context);
1123
+ return de_CommandError(output, context);
2444
1124
  }
2445
1125
  const data = await parseBody(output.body, context);
2446
1126
  let contents = {};
@@ -2451,31 +1131,9 @@ export const de_UntagResourceCommand = async (output, context) => {
2451
1131
  };
2452
1132
  return response;
2453
1133
  };
2454
- const de_UntagResourceCommandError = async (output, context) => {
2455
- const parsedOutput = {
2456
- ...output,
2457
- body: await parseErrorBody(output.body, context),
2458
- };
2459
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2460
- switch (errorCode) {
2461
- case "DirectConnectClientException":
2462
- case "com.amazonaws.directconnect#DirectConnectClientException":
2463
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
2464
- case "DirectConnectServerException":
2465
- case "com.amazonaws.directconnect#DirectConnectServerException":
2466
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
2467
- default:
2468
- const parsedBody = parsedOutput.body;
2469
- return throwDefaultError({
2470
- output,
2471
- parsedBody,
2472
- errorCode,
2473
- });
2474
- }
2475
- };
2476
1134
  export const de_UpdateConnectionCommand = async (output, context) => {
2477
1135
  if (output.statusCode >= 300) {
2478
- return de_UpdateConnectionCommandError(output, context);
1136
+ return de_CommandError(output, context);
2479
1137
  }
2480
1138
  const data = await parseBody(output.body, context);
2481
1139
  let contents = {};
@@ -2486,31 +1144,9 @@ export const de_UpdateConnectionCommand = async (output, context) => {
2486
1144
  };
2487
1145
  return response;
2488
1146
  };
2489
- const de_UpdateConnectionCommandError = async (output, context) => {
2490
- const parsedOutput = {
2491
- ...output,
2492
- body: await parseErrorBody(output.body, context),
2493
- };
2494
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2495
- switch (errorCode) {
2496
- case "DirectConnectClientException":
2497
- case "com.amazonaws.directconnect#DirectConnectClientException":
2498
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
2499
- case "DirectConnectServerException":
2500
- case "com.amazonaws.directconnect#DirectConnectServerException":
2501
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
2502
- default:
2503
- const parsedBody = parsedOutput.body;
2504
- return throwDefaultError({
2505
- output,
2506
- parsedBody,
2507
- errorCode,
2508
- });
2509
- }
2510
- };
2511
1147
  export const de_UpdateDirectConnectGatewayCommand = async (output, context) => {
2512
1148
  if (output.statusCode >= 300) {
2513
- return de_UpdateDirectConnectGatewayCommandError(output, context);
1149
+ return de_CommandError(output, context);
2514
1150
  }
2515
1151
  const data = await parseBody(output.body, context);
2516
1152
  let contents = {};
@@ -2521,31 +1157,9 @@ export const de_UpdateDirectConnectGatewayCommand = async (output, context) => {
2521
1157
  };
2522
1158
  return response;
2523
1159
  };
2524
- const de_UpdateDirectConnectGatewayCommandError = async (output, context) => {
2525
- const parsedOutput = {
2526
- ...output,
2527
- body: await parseErrorBody(output.body, context),
2528
- };
2529
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2530
- switch (errorCode) {
2531
- case "DirectConnectClientException":
2532
- case "com.amazonaws.directconnect#DirectConnectClientException":
2533
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
2534
- case "DirectConnectServerException":
2535
- case "com.amazonaws.directconnect#DirectConnectServerException":
2536
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
2537
- default:
2538
- const parsedBody = parsedOutput.body;
2539
- return throwDefaultError({
2540
- output,
2541
- parsedBody,
2542
- errorCode,
2543
- });
2544
- }
2545
- };
2546
1160
  export const de_UpdateDirectConnectGatewayAssociationCommand = async (output, context) => {
2547
1161
  if (output.statusCode >= 300) {
2548
- return de_UpdateDirectConnectGatewayAssociationCommandError(output, context);
1162
+ return de_CommandError(output, context);
2549
1163
  }
2550
1164
  const data = await parseBody(output.body, context);
2551
1165
  let contents = {};
@@ -2556,31 +1170,9 @@ export const de_UpdateDirectConnectGatewayAssociationCommand = async (output, co
2556
1170
  };
2557
1171
  return response;
2558
1172
  };
2559
- const de_UpdateDirectConnectGatewayAssociationCommandError = async (output, context) => {
2560
- const parsedOutput = {
2561
- ...output,
2562
- body: await parseErrorBody(output.body, context),
2563
- };
2564
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2565
- switch (errorCode) {
2566
- case "DirectConnectClientException":
2567
- case "com.amazonaws.directconnect#DirectConnectClientException":
2568
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
2569
- case "DirectConnectServerException":
2570
- case "com.amazonaws.directconnect#DirectConnectServerException":
2571
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
2572
- default:
2573
- const parsedBody = parsedOutput.body;
2574
- return throwDefaultError({
2575
- output,
2576
- parsedBody,
2577
- errorCode,
2578
- });
2579
- }
2580
- };
2581
1173
  export const de_UpdateLagCommand = async (output, context) => {
2582
1174
  if (output.statusCode >= 300) {
2583
- return de_UpdateLagCommandError(output, context);
1175
+ return de_CommandError(output, context);
2584
1176
  }
2585
1177
  const data = await parseBody(output.body, context);
2586
1178
  let contents = {};
@@ -2591,31 +1183,9 @@ export const de_UpdateLagCommand = async (output, context) => {
2591
1183
  };
2592
1184
  return response;
2593
1185
  };
2594
- const de_UpdateLagCommandError = async (output, context) => {
2595
- const parsedOutput = {
2596
- ...output,
2597
- body: await parseErrorBody(output.body, context),
2598
- };
2599
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2600
- switch (errorCode) {
2601
- case "DirectConnectClientException":
2602
- case "com.amazonaws.directconnect#DirectConnectClientException":
2603
- throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
2604
- case "DirectConnectServerException":
2605
- case "com.amazonaws.directconnect#DirectConnectServerException":
2606
- throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
2607
- default:
2608
- const parsedBody = parsedOutput.body;
2609
- return throwDefaultError({
2610
- output,
2611
- parsedBody,
2612
- errorCode,
2613
- });
2614
- }
2615
- };
2616
1186
  export const de_UpdateVirtualInterfaceAttributesCommand = async (output, context) => {
2617
1187
  if (output.statusCode >= 300) {
2618
- return de_UpdateVirtualInterfaceAttributesCommandError(output, context);
1188
+ return de_CommandError(output, context);
2619
1189
  }
2620
1190
  const data = await parseBody(output.body, context);
2621
1191
  let contents = {};
@@ -2626,7 +1196,7 @@ export const de_UpdateVirtualInterfaceAttributesCommand = async (output, context
2626
1196
  };
2627
1197
  return response;
2628
1198
  };
2629
- const de_UpdateVirtualInterfaceAttributesCommandError = async (output, context) => {
1199
+ const de_CommandError = async (output, context) => {
2630
1200
  const parsedOutput = {
2631
1201
  ...output,
2632
1202
  body: await parseErrorBody(output.body, context),
@@ -2639,6 +1209,12 @@ const de_UpdateVirtualInterfaceAttributesCommandError = async (output, context)
2639
1209
  case "DirectConnectServerException":
2640
1210
  case "com.amazonaws.directconnect#DirectConnectServerException":
2641
1211
  throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
1212
+ case "DuplicateTagKeysException":
1213
+ case "com.amazonaws.directconnect#DuplicateTagKeysException":
1214
+ throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
1215
+ case "TooManyTagsException":
1216
+ case "com.amazonaws.directconnect#TooManyTagsException":
1217
+ throw await de_TooManyTagsExceptionRes(parsedOutput, context);
2642
1218
  default:
2643
1219
  const parsedBody = parsedOutput.body;
2644
1220
  return throwDefaultError({