@aws-sdk/client-securitylake 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 +33 -1053
  2. package/dist-es/protocols/Aws_restJson1.js +32 -1052
  3. package/package.json +3 -3
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -410,7 +410,7 @@ export const se_UpdateSubscriberNotificationCommand = async (input, context) =>
410
410
  };
411
411
  export const de_CreateAwsLogSourceCommand = async (output, context) => {
412
412
  if (output.statusCode !== 200 && output.statusCode >= 300) {
413
- return de_CreateAwsLogSourceCommandError(output, context);
413
+ return de_CommandError(output, context);
414
414
  }
415
415
  const contents = map({
416
416
  $metadata: deserializeMetadata(output),
@@ -422,43 +422,9 @@ export const de_CreateAwsLogSourceCommand = async (output, context) => {
422
422
  Object.assign(contents, doc);
423
423
  return contents;
424
424
  };
425
- const de_CreateAwsLogSourceCommandError = async (output, context) => {
426
- const parsedOutput = {
427
- ...output,
428
- body: await parseErrorBody(output.body, context),
429
- };
430
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
431
- switch (errorCode) {
432
- case "AccessDeniedException":
433
- case "com.amazonaws.securitylake#AccessDeniedException":
434
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
435
- case "BadRequestException":
436
- case "com.amazonaws.securitylake#BadRequestException":
437
- throw await de_BadRequestExceptionRes(parsedOutput, context);
438
- case "ConflictException":
439
- case "com.amazonaws.securitylake#ConflictException":
440
- throw await de_ConflictExceptionRes(parsedOutput, context);
441
- case "InternalServerException":
442
- case "com.amazonaws.securitylake#InternalServerException":
443
- throw await de_InternalServerExceptionRes(parsedOutput, context);
444
- case "ResourceNotFoundException":
445
- case "com.amazonaws.securitylake#ResourceNotFoundException":
446
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
447
- case "ThrottlingException":
448
- case "com.amazonaws.securitylake#ThrottlingException":
449
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
450
- default:
451
- const parsedBody = parsedOutput.body;
452
- return throwDefaultError({
453
- output,
454
- parsedBody,
455
- errorCode,
456
- });
457
- }
458
- };
459
425
  export const de_CreateCustomLogSourceCommand = async (output, context) => {
460
426
  if (output.statusCode !== 200 && output.statusCode >= 300) {
461
- return de_CreateCustomLogSourceCommandError(output, context);
427
+ return de_CommandError(output, context);
462
428
  }
463
429
  const contents = map({
464
430
  $metadata: deserializeMetadata(output),
@@ -470,43 +436,9 @@ export const de_CreateCustomLogSourceCommand = async (output, context) => {
470
436
  Object.assign(contents, doc);
471
437
  return contents;
472
438
  };
473
- const de_CreateCustomLogSourceCommandError = async (output, context) => {
474
- const parsedOutput = {
475
- ...output,
476
- body: await parseErrorBody(output.body, context),
477
- };
478
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
479
- switch (errorCode) {
480
- case "AccessDeniedException":
481
- case "com.amazonaws.securitylake#AccessDeniedException":
482
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
483
- case "BadRequestException":
484
- case "com.amazonaws.securitylake#BadRequestException":
485
- throw await de_BadRequestExceptionRes(parsedOutput, context);
486
- case "ConflictException":
487
- case "com.amazonaws.securitylake#ConflictException":
488
- throw await de_ConflictExceptionRes(parsedOutput, context);
489
- case "InternalServerException":
490
- case "com.amazonaws.securitylake#InternalServerException":
491
- throw await de_InternalServerExceptionRes(parsedOutput, context);
492
- case "ResourceNotFoundException":
493
- case "com.amazonaws.securitylake#ResourceNotFoundException":
494
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
495
- case "ThrottlingException":
496
- case "com.amazonaws.securitylake#ThrottlingException":
497
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
498
- default:
499
- const parsedBody = parsedOutput.body;
500
- return throwDefaultError({
501
- output,
502
- parsedBody,
503
- errorCode,
504
- });
505
- }
506
- };
507
439
  export const de_CreateDataLakeCommand = async (output, context) => {
508
440
  if (output.statusCode !== 200 && output.statusCode >= 300) {
509
- return de_CreateDataLakeCommandError(output, context);
441
+ return de_CommandError(output, context);
510
442
  }
511
443
  const contents = map({
512
444
  $metadata: deserializeMetadata(output),
@@ -518,43 +450,9 @@ export const de_CreateDataLakeCommand = async (output, context) => {
518
450
  Object.assign(contents, doc);
519
451
  return contents;
520
452
  };
521
- const de_CreateDataLakeCommandError = async (output, context) => {
522
- const parsedOutput = {
523
- ...output,
524
- body: await parseErrorBody(output.body, context),
525
- };
526
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
527
- switch (errorCode) {
528
- case "AccessDeniedException":
529
- case "com.amazonaws.securitylake#AccessDeniedException":
530
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
531
- case "BadRequestException":
532
- case "com.amazonaws.securitylake#BadRequestException":
533
- throw await de_BadRequestExceptionRes(parsedOutput, context);
534
- case "ConflictException":
535
- case "com.amazonaws.securitylake#ConflictException":
536
- throw await de_ConflictExceptionRes(parsedOutput, context);
537
- case "InternalServerException":
538
- case "com.amazonaws.securitylake#InternalServerException":
539
- throw await de_InternalServerExceptionRes(parsedOutput, context);
540
- case "ResourceNotFoundException":
541
- case "com.amazonaws.securitylake#ResourceNotFoundException":
542
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
543
- case "ThrottlingException":
544
- case "com.amazonaws.securitylake#ThrottlingException":
545
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
546
- default:
547
- const parsedBody = parsedOutput.body;
548
- return throwDefaultError({
549
- output,
550
- parsedBody,
551
- errorCode,
552
- });
553
- }
554
- };
555
453
  export const de_CreateDataLakeExceptionSubscriptionCommand = async (output, context) => {
556
454
  if (output.statusCode !== 200 && output.statusCode >= 300) {
557
- return de_CreateDataLakeExceptionSubscriptionCommandError(output, context);
455
+ return de_CommandError(output, context);
558
456
  }
559
457
  const contents = map({
560
458
  $metadata: deserializeMetadata(output),
@@ -562,43 +460,9 @@ export const de_CreateDataLakeExceptionSubscriptionCommand = async (output, cont
562
460
  await collectBody(output.body, context);
563
461
  return contents;
564
462
  };
565
- const de_CreateDataLakeExceptionSubscriptionCommandError = async (output, context) => {
566
- const parsedOutput = {
567
- ...output,
568
- body: await parseErrorBody(output.body, context),
569
- };
570
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
571
- switch (errorCode) {
572
- case "AccessDeniedException":
573
- case "com.amazonaws.securitylake#AccessDeniedException":
574
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
575
- case "BadRequestException":
576
- case "com.amazonaws.securitylake#BadRequestException":
577
- throw await de_BadRequestExceptionRes(parsedOutput, context);
578
- case "ConflictException":
579
- case "com.amazonaws.securitylake#ConflictException":
580
- throw await de_ConflictExceptionRes(parsedOutput, context);
581
- case "InternalServerException":
582
- case "com.amazonaws.securitylake#InternalServerException":
583
- throw await de_InternalServerExceptionRes(parsedOutput, context);
584
- case "ResourceNotFoundException":
585
- case "com.amazonaws.securitylake#ResourceNotFoundException":
586
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
587
- case "ThrottlingException":
588
- case "com.amazonaws.securitylake#ThrottlingException":
589
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
590
- default:
591
- const parsedBody = parsedOutput.body;
592
- return throwDefaultError({
593
- output,
594
- parsedBody,
595
- errorCode,
596
- });
597
- }
598
- };
599
463
  export const de_CreateDataLakeOrganizationConfigurationCommand = async (output, context) => {
600
464
  if (output.statusCode !== 200 && output.statusCode >= 300) {
601
- return de_CreateDataLakeOrganizationConfigurationCommandError(output, context);
465
+ return de_CommandError(output, context);
602
466
  }
603
467
  const contents = map({
604
468
  $metadata: deserializeMetadata(output),
@@ -606,43 +470,9 @@ export const de_CreateDataLakeOrganizationConfigurationCommand = async (output,
606
470
  await collectBody(output.body, context);
607
471
  return contents;
608
472
  };
609
- const de_CreateDataLakeOrganizationConfigurationCommandError = async (output, context) => {
610
- const parsedOutput = {
611
- ...output,
612
- body: await parseErrorBody(output.body, context),
613
- };
614
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
615
- switch (errorCode) {
616
- case "AccessDeniedException":
617
- case "com.amazonaws.securitylake#AccessDeniedException":
618
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
619
- case "BadRequestException":
620
- case "com.amazonaws.securitylake#BadRequestException":
621
- throw await de_BadRequestExceptionRes(parsedOutput, context);
622
- case "ConflictException":
623
- case "com.amazonaws.securitylake#ConflictException":
624
- throw await de_ConflictExceptionRes(parsedOutput, context);
625
- case "InternalServerException":
626
- case "com.amazonaws.securitylake#InternalServerException":
627
- throw await de_InternalServerExceptionRes(parsedOutput, context);
628
- case "ResourceNotFoundException":
629
- case "com.amazonaws.securitylake#ResourceNotFoundException":
630
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
631
- case "ThrottlingException":
632
- case "com.amazonaws.securitylake#ThrottlingException":
633
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
634
- default:
635
- const parsedBody = parsedOutput.body;
636
- return throwDefaultError({
637
- output,
638
- parsedBody,
639
- errorCode,
640
- });
641
- }
642
- };
643
473
  export const de_CreateSubscriberCommand = async (output, context) => {
644
474
  if (output.statusCode !== 200 && output.statusCode >= 300) {
645
- return de_CreateSubscriberCommandError(output, context);
475
+ return de_CommandError(output, context);
646
476
  }
647
477
  const contents = map({
648
478
  $metadata: deserializeMetadata(output),
@@ -654,43 +484,9 @@ export const de_CreateSubscriberCommand = async (output, context) => {
654
484
  Object.assign(contents, doc);
655
485
  return contents;
656
486
  };
657
- const de_CreateSubscriberCommandError = async (output, context) => {
658
- const parsedOutput = {
659
- ...output,
660
- body: await parseErrorBody(output.body, context),
661
- };
662
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
663
- switch (errorCode) {
664
- case "AccessDeniedException":
665
- case "com.amazonaws.securitylake#AccessDeniedException":
666
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
667
- case "BadRequestException":
668
- case "com.amazonaws.securitylake#BadRequestException":
669
- throw await de_BadRequestExceptionRes(parsedOutput, context);
670
- case "ConflictException":
671
- case "com.amazonaws.securitylake#ConflictException":
672
- throw await de_ConflictExceptionRes(parsedOutput, context);
673
- case "InternalServerException":
674
- case "com.amazonaws.securitylake#InternalServerException":
675
- throw await de_InternalServerExceptionRes(parsedOutput, context);
676
- case "ResourceNotFoundException":
677
- case "com.amazonaws.securitylake#ResourceNotFoundException":
678
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
679
- case "ThrottlingException":
680
- case "com.amazonaws.securitylake#ThrottlingException":
681
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
682
- default:
683
- const parsedBody = parsedOutput.body;
684
- return throwDefaultError({
685
- output,
686
- parsedBody,
687
- errorCode,
688
- });
689
- }
690
- };
691
487
  export const de_CreateSubscriberNotificationCommand = async (output, context) => {
692
488
  if (output.statusCode !== 200 && output.statusCode >= 300) {
693
- return de_CreateSubscriberNotificationCommandError(output, context);
489
+ return de_CommandError(output, context);
694
490
  }
695
491
  const contents = map({
696
492
  $metadata: deserializeMetadata(output),
@@ -702,43 +498,9 @@ export const de_CreateSubscriberNotificationCommand = async (output, context) =>
702
498
  Object.assign(contents, doc);
703
499
  return contents;
704
500
  };
705
- const de_CreateSubscriberNotificationCommandError = async (output, context) => {
706
- const parsedOutput = {
707
- ...output,
708
- body: await parseErrorBody(output.body, context),
709
- };
710
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
711
- switch (errorCode) {
712
- case "AccessDeniedException":
713
- case "com.amazonaws.securitylake#AccessDeniedException":
714
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
715
- case "BadRequestException":
716
- case "com.amazonaws.securitylake#BadRequestException":
717
- throw await de_BadRequestExceptionRes(parsedOutput, context);
718
- case "ConflictException":
719
- case "com.amazonaws.securitylake#ConflictException":
720
- throw await de_ConflictExceptionRes(parsedOutput, context);
721
- case "InternalServerException":
722
- case "com.amazonaws.securitylake#InternalServerException":
723
- throw await de_InternalServerExceptionRes(parsedOutput, context);
724
- case "ResourceNotFoundException":
725
- case "com.amazonaws.securitylake#ResourceNotFoundException":
726
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
727
- case "ThrottlingException":
728
- case "com.amazonaws.securitylake#ThrottlingException":
729
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
730
- default:
731
- const parsedBody = parsedOutput.body;
732
- return throwDefaultError({
733
- output,
734
- parsedBody,
735
- errorCode,
736
- });
737
- }
738
- };
739
501
  export const de_DeleteAwsLogSourceCommand = async (output, context) => {
740
502
  if (output.statusCode !== 200 && output.statusCode >= 300) {
741
- return de_DeleteAwsLogSourceCommandError(output, context);
503
+ return de_CommandError(output, context);
742
504
  }
743
505
  const contents = map({
744
506
  $metadata: deserializeMetadata(output),
@@ -750,43 +512,9 @@ export const de_DeleteAwsLogSourceCommand = async (output, context) => {
750
512
  Object.assign(contents, doc);
751
513
  return contents;
752
514
  };
753
- const de_DeleteAwsLogSourceCommandError = async (output, context) => {
754
- const parsedOutput = {
755
- ...output,
756
- body: await parseErrorBody(output.body, context),
757
- };
758
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
759
- switch (errorCode) {
760
- case "AccessDeniedException":
761
- case "com.amazonaws.securitylake#AccessDeniedException":
762
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
763
- case "BadRequestException":
764
- case "com.amazonaws.securitylake#BadRequestException":
765
- throw await de_BadRequestExceptionRes(parsedOutput, context);
766
- case "ConflictException":
767
- case "com.amazonaws.securitylake#ConflictException":
768
- throw await de_ConflictExceptionRes(parsedOutput, context);
769
- case "InternalServerException":
770
- case "com.amazonaws.securitylake#InternalServerException":
771
- throw await de_InternalServerExceptionRes(parsedOutput, context);
772
- case "ResourceNotFoundException":
773
- case "com.amazonaws.securitylake#ResourceNotFoundException":
774
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
775
- case "ThrottlingException":
776
- case "com.amazonaws.securitylake#ThrottlingException":
777
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
778
- default:
779
- const parsedBody = parsedOutput.body;
780
- return throwDefaultError({
781
- output,
782
- parsedBody,
783
- errorCode,
784
- });
785
- }
786
- };
787
515
  export const de_DeleteCustomLogSourceCommand = async (output, context) => {
788
516
  if (output.statusCode !== 200 && output.statusCode >= 300) {
789
- return de_DeleteCustomLogSourceCommandError(output, context);
517
+ return de_CommandError(output, context);
790
518
  }
791
519
  const contents = map({
792
520
  $metadata: deserializeMetadata(output),
@@ -794,43 +522,9 @@ export const de_DeleteCustomLogSourceCommand = async (output, context) => {
794
522
  await collectBody(output.body, context);
795
523
  return contents;
796
524
  };
797
- const de_DeleteCustomLogSourceCommandError = async (output, context) => {
798
- const parsedOutput = {
799
- ...output,
800
- body: await parseErrorBody(output.body, context),
801
- };
802
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
803
- switch (errorCode) {
804
- case "AccessDeniedException":
805
- case "com.amazonaws.securitylake#AccessDeniedException":
806
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
807
- case "BadRequestException":
808
- case "com.amazonaws.securitylake#BadRequestException":
809
- throw await de_BadRequestExceptionRes(parsedOutput, context);
810
- case "ConflictException":
811
- case "com.amazonaws.securitylake#ConflictException":
812
- throw await de_ConflictExceptionRes(parsedOutput, context);
813
- case "InternalServerException":
814
- case "com.amazonaws.securitylake#InternalServerException":
815
- throw await de_InternalServerExceptionRes(parsedOutput, context);
816
- case "ResourceNotFoundException":
817
- case "com.amazonaws.securitylake#ResourceNotFoundException":
818
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
819
- case "ThrottlingException":
820
- case "com.amazonaws.securitylake#ThrottlingException":
821
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
822
- default:
823
- const parsedBody = parsedOutput.body;
824
- return throwDefaultError({
825
- output,
826
- parsedBody,
827
- errorCode,
828
- });
829
- }
830
- };
831
525
  export const de_DeleteDataLakeCommand = async (output, context) => {
832
526
  if (output.statusCode !== 200 && output.statusCode >= 300) {
833
- return de_DeleteDataLakeCommandError(output, context);
527
+ return de_CommandError(output, context);
834
528
  }
835
529
  const contents = map({
836
530
  $metadata: deserializeMetadata(output),
@@ -838,43 +532,9 @@ export const de_DeleteDataLakeCommand = async (output, context) => {
838
532
  await collectBody(output.body, context);
839
533
  return contents;
840
534
  };
841
- const de_DeleteDataLakeCommandError = async (output, context) => {
842
- const parsedOutput = {
843
- ...output,
844
- body: await parseErrorBody(output.body, context),
845
- };
846
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
847
- switch (errorCode) {
848
- case "AccessDeniedException":
849
- case "com.amazonaws.securitylake#AccessDeniedException":
850
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
851
- case "BadRequestException":
852
- case "com.amazonaws.securitylake#BadRequestException":
853
- throw await de_BadRequestExceptionRes(parsedOutput, context);
854
- case "ConflictException":
855
- case "com.amazonaws.securitylake#ConflictException":
856
- throw await de_ConflictExceptionRes(parsedOutput, context);
857
- case "InternalServerException":
858
- case "com.amazonaws.securitylake#InternalServerException":
859
- throw await de_InternalServerExceptionRes(parsedOutput, context);
860
- case "ResourceNotFoundException":
861
- case "com.amazonaws.securitylake#ResourceNotFoundException":
862
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
863
- case "ThrottlingException":
864
- case "com.amazonaws.securitylake#ThrottlingException":
865
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
866
- default:
867
- const parsedBody = parsedOutput.body;
868
- return throwDefaultError({
869
- output,
870
- parsedBody,
871
- errorCode,
872
- });
873
- }
874
- };
875
535
  export const de_DeleteDataLakeExceptionSubscriptionCommand = async (output, context) => {
876
536
  if (output.statusCode !== 200 && output.statusCode >= 300) {
877
- return de_DeleteDataLakeExceptionSubscriptionCommandError(output, context);
537
+ return de_CommandError(output, context);
878
538
  }
879
539
  const contents = map({
880
540
  $metadata: deserializeMetadata(output),
@@ -882,43 +542,9 @@ export const de_DeleteDataLakeExceptionSubscriptionCommand = async (output, cont
882
542
  await collectBody(output.body, context);
883
543
  return contents;
884
544
  };
885
- const de_DeleteDataLakeExceptionSubscriptionCommandError = async (output, context) => {
886
- const parsedOutput = {
887
- ...output,
888
- body: await parseErrorBody(output.body, context),
889
- };
890
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
891
- switch (errorCode) {
892
- case "AccessDeniedException":
893
- case "com.amazonaws.securitylake#AccessDeniedException":
894
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
895
- case "BadRequestException":
896
- case "com.amazonaws.securitylake#BadRequestException":
897
- throw await de_BadRequestExceptionRes(parsedOutput, context);
898
- case "ConflictException":
899
- case "com.amazonaws.securitylake#ConflictException":
900
- throw await de_ConflictExceptionRes(parsedOutput, context);
901
- case "InternalServerException":
902
- case "com.amazonaws.securitylake#InternalServerException":
903
- throw await de_InternalServerExceptionRes(parsedOutput, context);
904
- case "ResourceNotFoundException":
905
- case "com.amazonaws.securitylake#ResourceNotFoundException":
906
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
907
- case "ThrottlingException":
908
- case "com.amazonaws.securitylake#ThrottlingException":
909
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
910
- default:
911
- const parsedBody = parsedOutput.body;
912
- return throwDefaultError({
913
- output,
914
- parsedBody,
915
- errorCode,
916
- });
917
- }
918
- };
919
545
  export const de_DeleteDataLakeOrganizationConfigurationCommand = async (output, context) => {
920
546
  if (output.statusCode !== 200 && output.statusCode >= 300) {
921
- return de_DeleteDataLakeOrganizationConfigurationCommandError(output, context);
547
+ return de_CommandError(output, context);
922
548
  }
923
549
  const contents = map({
924
550
  $metadata: deserializeMetadata(output),
@@ -926,43 +552,9 @@ export const de_DeleteDataLakeOrganizationConfigurationCommand = async (output,
926
552
  await collectBody(output.body, context);
927
553
  return contents;
928
554
  };
929
- const de_DeleteDataLakeOrganizationConfigurationCommandError = async (output, context) => {
930
- const parsedOutput = {
931
- ...output,
932
- body: await parseErrorBody(output.body, context),
933
- };
934
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
935
- switch (errorCode) {
936
- case "AccessDeniedException":
937
- case "com.amazonaws.securitylake#AccessDeniedException":
938
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
939
- case "BadRequestException":
940
- case "com.amazonaws.securitylake#BadRequestException":
941
- throw await de_BadRequestExceptionRes(parsedOutput, context);
942
- case "ConflictException":
943
- case "com.amazonaws.securitylake#ConflictException":
944
- throw await de_ConflictExceptionRes(parsedOutput, context);
945
- case "InternalServerException":
946
- case "com.amazonaws.securitylake#InternalServerException":
947
- throw await de_InternalServerExceptionRes(parsedOutput, context);
948
- case "ResourceNotFoundException":
949
- case "com.amazonaws.securitylake#ResourceNotFoundException":
950
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
951
- case "ThrottlingException":
952
- case "com.amazonaws.securitylake#ThrottlingException":
953
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
954
- default:
955
- const parsedBody = parsedOutput.body;
956
- return throwDefaultError({
957
- output,
958
- parsedBody,
959
- errorCode,
960
- });
961
- }
962
- };
963
555
  export const de_DeleteSubscriberCommand = async (output, context) => {
964
556
  if (output.statusCode !== 200 && output.statusCode >= 300) {
965
- return de_DeleteSubscriberCommandError(output, context);
557
+ return de_CommandError(output, context);
966
558
  }
967
559
  const contents = map({
968
560
  $metadata: deserializeMetadata(output),
@@ -970,43 +562,9 @@ export const de_DeleteSubscriberCommand = async (output, context) => {
970
562
  await collectBody(output.body, context);
971
563
  return contents;
972
564
  };
973
- const de_DeleteSubscriberCommandError = async (output, context) => {
974
- const parsedOutput = {
975
- ...output,
976
- body: await parseErrorBody(output.body, context),
977
- };
978
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
979
- switch (errorCode) {
980
- case "AccessDeniedException":
981
- case "com.amazonaws.securitylake#AccessDeniedException":
982
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
983
- case "BadRequestException":
984
- case "com.amazonaws.securitylake#BadRequestException":
985
- throw await de_BadRequestExceptionRes(parsedOutput, context);
986
- case "ConflictException":
987
- case "com.amazonaws.securitylake#ConflictException":
988
- throw await de_ConflictExceptionRes(parsedOutput, context);
989
- case "InternalServerException":
990
- case "com.amazonaws.securitylake#InternalServerException":
991
- throw await de_InternalServerExceptionRes(parsedOutput, context);
992
- case "ResourceNotFoundException":
993
- case "com.amazonaws.securitylake#ResourceNotFoundException":
994
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
995
- case "ThrottlingException":
996
- case "com.amazonaws.securitylake#ThrottlingException":
997
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
998
- default:
999
- const parsedBody = parsedOutput.body;
1000
- return throwDefaultError({
1001
- output,
1002
- parsedBody,
1003
- errorCode,
1004
- });
1005
- }
1006
- };
1007
565
  export const de_DeleteSubscriberNotificationCommand = async (output, context) => {
1008
566
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1009
- return de_DeleteSubscriberNotificationCommandError(output, context);
567
+ return de_CommandError(output, context);
1010
568
  }
1011
569
  const contents = map({
1012
570
  $metadata: deserializeMetadata(output),
@@ -1014,43 +572,9 @@ export const de_DeleteSubscriberNotificationCommand = async (output, context) =>
1014
572
  await collectBody(output.body, context);
1015
573
  return contents;
1016
574
  };
1017
- const de_DeleteSubscriberNotificationCommandError = async (output, context) => {
1018
- const parsedOutput = {
1019
- ...output,
1020
- body: await parseErrorBody(output.body, context),
1021
- };
1022
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1023
- switch (errorCode) {
1024
- case "AccessDeniedException":
1025
- case "com.amazonaws.securitylake#AccessDeniedException":
1026
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1027
- case "BadRequestException":
1028
- case "com.amazonaws.securitylake#BadRequestException":
1029
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1030
- case "ConflictException":
1031
- case "com.amazonaws.securitylake#ConflictException":
1032
- throw await de_ConflictExceptionRes(parsedOutput, context);
1033
- case "InternalServerException":
1034
- case "com.amazonaws.securitylake#InternalServerException":
1035
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1036
- case "ResourceNotFoundException":
1037
- case "com.amazonaws.securitylake#ResourceNotFoundException":
1038
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1039
- case "ThrottlingException":
1040
- case "com.amazonaws.securitylake#ThrottlingException":
1041
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1042
- default:
1043
- const parsedBody = parsedOutput.body;
1044
- return throwDefaultError({
1045
- output,
1046
- parsedBody,
1047
- errorCode,
1048
- });
1049
- }
1050
- };
1051
575
  export const de_DeregisterDataLakeDelegatedAdministratorCommand = async (output, context) => {
1052
576
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1053
- return de_DeregisterDataLakeDelegatedAdministratorCommandError(output, context);
577
+ return de_CommandError(output, context);
1054
578
  }
1055
579
  const contents = map({
1056
580
  $metadata: deserializeMetadata(output),
@@ -1058,43 +582,9 @@ export const de_DeregisterDataLakeDelegatedAdministratorCommand = async (output,
1058
582
  await collectBody(output.body, context);
1059
583
  return contents;
1060
584
  };
1061
- const de_DeregisterDataLakeDelegatedAdministratorCommandError = async (output, context) => {
1062
- const parsedOutput = {
1063
- ...output,
1064
- body: await parseErrorBody(output.body, context),
1065
- };
1066
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1067
- switch (errorCode) {
1068
- case "AccessDeniedException":
1069
- case "com.amazonaws.securitylake#AccessDeniedException":
1070
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1071
- case "BadRequestException":
1072
- case "com.amazonaws.securitylake#BadRequestException":
1073
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1074
- case "ConflictException":
1075
- case "com.amazonaws.securitylake#ConflictException":
1076
- throw await de_ConflictExceptionRes(parsedOutput, context);
1077
- case "InternalServerException":
1078
- case "com.amazonaws.securitylake#InternalServerException":
1079
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1080
- case "ResourceNotFoundException":
1081
- case "com.amazonaws.securitylake#ResourceNotFoundException":
1082
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1083
- case "ThrottlingException":
1084
- case "com.amazonaws.securitylake#ThrottlingException":
1085
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1086
- default:
1087
- const parsedBody = parsedOutput.body;
1088
- return throwDefaultError({
1089
- output,
1090
- parsedBody,
1091
- errorCode,
1092
- });
1093
- }
1094
- };
1095
585
  export const de_GetDataLakeExceptionSubscriptionCommand = async (output, context) => {
1096
586
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1097
- return de_GetDataLakeExceptionSubscriptionCommandError(output, context);
587
+ return de_CommandError(output, context);
1098
588
  }
1099
589
  const contents = map({
1100
590
  $metadata: deserializeMetadata(output),
@@ -1108,43 +598,9 @@ export const de_GetDataLakeExceptionSubscriptionCommand = async (output, context
1108
598
  Object.assign(contents, doc);
1109
599
  return contents;
1110
600
  };
1111
- const de_GetDataLakeExceptionSubscriptionCommandError = async (output, context) => {
1112
- const parsedOutput = {
1113
- ...output,
1114
- body: await parseErrorBody(output.body, context),
1115
- };
1116
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1117
- switch (errorCode) {
1118
- case "AccessDeniedException":
1119
- case "com.amazonaws.securitylake#AccessDeniedException":
1120
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1121
- case "BadRequestException":
1122
- case "com.amazonaws.securitylake#BadRequestException":
1123
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1124
- case "ConflictException":
1125
- case "com.amazonaws.securitylake#ConflictException":
1126
- throw await de_ConflictExceptionRes(parsedOutput, context);
1127
- case "InternalServerException":
1128
- case "com.amazonaws.securitylake#InternalServerException":
1129
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1130
- case "ResourceNotFoundException":
1131
- case "com.amazonaws.securitylake#ResourceNotFoundException":
1132
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1133
- case "ThrottlingException":
1134
- case "com.amazonaws.securitylake#ThrottlingException":
1135
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1136
- default:
1137
- const parsedBody = parsedOutput.body;
1138
- return throwDefaultError({
1139
- output,
1140
- parsedBody,
1141
- errorCode,
1142
- });
1143
- }
1144
- };
1145
601
  export const de_GetDataLakeOrganizationConfigurationCommand = async (output, context) => {
1146
602
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1147
- return de_GetDataLakeOrganizationConfigurationCommandError(output, context);
603
+ return de_CommandError(output, context);
1148
604
  }
1149
605
  const contents = map({
1150
606
  $metadata: deserializeMetadata(output),
@@ -1156,43 +612,9 @@ export const de_GetDataLakeOrganizationConfigurationCommand = async (output, con
1156
612
  Object.assign(contents, doc);
1157
613
  return contents;
1158
614
  };
1159
- const de_GetDataLakeOrganizationConfigurationCommandError = async (output, context) => {
1160
- const parsedOutput = {
1161
- ...output,
1162
- body: await parseErrorBody(output.body, context),
1163
- };
1164
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1165
- switch (errorCode) {
1166
- case "AccessDeniedException":
1167
- case "com.amazonaws.securitylake#AccessDeniedException":
1168
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1169
- case "BadRequestException":
1170
- case "com.amazonaws.securitylake#BadRequestException":
1171
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1172
- case "ConflictException":
1173
- case "com.amazonaws.securitylake#ConflictException":
1174
- throw await de_ConflictExceptionRes(parsedOutput, context);
1175
- case "InternalServerException":
1176
- case "com.amazonaws.securitylake#InternalServerException":
1177
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1178
- case "ResourceNotFoundException":
1179
- case "com.amazonaws.securitylake#ResourceNotFoundException":
1180
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1181
- case "ThrottlingException":
1182
- case "com.amazonaws.securitylake#ThrottlingException":
1183
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1184
- default:
1185
- const parsedBody = parsedOutput.body;
1186
- return throwDefaultError({
1187
- output,
1188
- parsedBody,
1189
- errorCode,
1190
- });
1191
- }
1192
- };
1193
615
  export const de_GetDataLakeSourcesCommand = async (output, context) => {
1194
616
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1195
- return de_GetDataLakeSourcesCommandError(output, context);
617
+ return de_CommandError(output, context);
1196
618
  }
1197
619
  const contents = map({
1198
620
  $metadata: deserializeMetadata(output),
@@ -1206,43 +628,9 @@ export const de_GetDataLakeSourcesCommand = async (output, context) => {
1206
628
  Object.assign(contents, doc);
1207
629
  return contents;
1208
630
  };
1209
- const de_GetDataLakeSourcesCommandError = async (output, context) => {
1210
- const parsedOutput = {
1211
- ...output,
1212
- body: await parseErrorBody(output.body, context),
1213
- };
1214
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1215
- switch (errorCode) {
1216
- case "AccessDeniedException":
1217
- case "com.amazonaws.securitylake#AccessDeniedException":
1218
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1219
- case "BadRequestException":
1220
- case "com.amazonaws.securitylake#BadRequestException":
1221
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1222
- case "ConflictException":
1223
- case "com.amazonaws.securitylake#ConflictException":
1224
- throw await de_ConflictExceptionRes(parsedOutput, context);
1225
- case "InternalServerException":
1226
- case "com.amazonaws.securitylake#InternalServerException":
1227
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1228
- case "ResourceNotFoundException":
1229
- case "com.amazonaws.securitylake#ResourceNotFoundException":
1230
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1231
- case "ThrottlingException":
1232
- case "com.amazonaws.securitylake#ThrottlingException":
1233
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1234
- default:
1235
- const parsedBody = parsedOutput.body;
1236
- return throwDefaultError({
1237
- output,
1238
- parsedBody,
1239
- errorCode,
1240
- });
1241
- }
1242
- };
1243
631
  export const de_GetSubscriberCommand = async (output, context) => {
1244
632
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1245
- return de_GetSubscriberCommandError(output, context);
633
+ return de_CommandError(output, context);
1246
634
  }
1247
635
  const contents = map({
1248
636
  $metadata: deserializeMetadata(output),
@@ -1254,43 +642,9 @@ export const de_GetSubscriberCommand = async (output, context) => {
1254
642
  Object.assign(contents, doc);
1255
643
  return contents;
1256
644
  };
1257
- const de_GetSubscriberCommandError = async (output, context) => {
1258
- const parsedOutput = {
1259
- ...output,
1260
- body: await parseErrorBody(output.body, context),
1261
- };
1262
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1263
- switch (errorCode) {
1264
- case "AccessDeniedException":
1265
- case "com.amazonaws.securitylake#AccessDeniedException":
1266
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1267
- case "BadRequestException":
1268
- case "com.amazonaws.securitylake#BadRequestException":
1269
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1270
- case "ConflictException":
1271
- case "com.amazonaws.securitylake#ConflictException":
1272
- throw await de_ConflictExceptionRes(parsedOutput, context);
1273
- case "InternalServerException":
1274
- case "com.amazonaws.securitylake#InternalServerException":
1275
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1276
- case "ResourceNotFoundException":
1277
- case "com.amazonaws.securitylake#ResourceNotFoundException":
1278
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1279
- case "ThrottlingException":
1280
- case "com.amazonaws.securitylake#ThrottlingException":
1281
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1282
- default:
1283
- const parsedBody = parsedOutput.body;
1284
- return throwDefaultError({
1285
- output,
1286
- parsedBody,
1287
- errorCode,
1288
- });
1289
- }
1290
- };
1291
645
  export const de_ListDataLakeExceptionsCommand = async (output, context) => {
1292
646
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1293
- return de_ListDataLakeExceptionsCommandError(output, context);
647
+ return de_CommandError(output, context);
1294
648
  }
1295
649
  const contents = map({
1296
650
  $metadata: deserializeMetadata(output),
@@ -1303,43 +657,9 @@ export const de_ListDataLakeExceptionsCommand = async (output, context) => {
1303
657
  Object.assign(contents, doc);
1304
658
  return contents;
1305
659
  };
1306
- const de_ListDataLakeExceptionsCommandError = async (output, context) => {
1307
- const parsedOutput = {
1308
- ...output,
1309
- body: await parseErrorBody(output.body, context),
1310
- };
1311
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1312
- switch (errorCode) {
1313
- case "AccessDeniedException":
1314
- case "com.amazonaws.securitylake#AccessDeniedException":
1315
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1316
- case "BadRequestException":
1317
- case "com.amazonaws.securitylake#BadRequestException":
1318
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1319
- case "ConflictException":
1320
- case "com.amazonaws.securitylake#ConflictException":
1321
- throw await de_ConflictExceptionRes(parsedOutput, context);
1322
- case "InternalServerException":
1323
- case "com.amazonaws.securitylake#InternalServerException":
1324
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1325
- case "ResourceNotFoundException":
1326
- case "com.amazonaws.securitylake#ResourceNotFoundException":
1327
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1328
- case "ThrottlingException":
1329
- case "com.amazonaws.securitylake#ThrottlingException":
1330
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1331
- default:
1332
- const parsedBody = parsedOutput.body;
1333
- return throwDefaultError({
1334
- output,
1335
- parsedBody,
1336
- errorCode,
1337
- });
1338
- }
1339
- };
1340
660
  export const de_ListDataLakesCommand = async (output, context) => {
1341
661
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1342
- return de_ListDataLakesCommandError(output, context);
662
+ return de_CommandError(output, context);
1343
663
  }
1344
664
  const contents = map({
1345
665
  $metadata: deserializeMetadata(output),
@@ -1351,43 +671,9 @@ export const de_ListDataLakesCommand = async (output, context) => {
1351
671
  Object.assign(contents, doc);
1352
672
  return contents;
1353
673
  };
1354
- const de_ListDataLakesCommandError = async (output, context) => {
1355
- const parsedOutput = {
1356
- ...output,
1357
- body: await parseErrorBody(output.body, context),
1358
- };
1359
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1360
- switch (errorCode) {
1361
- case "AccessDeniedException":
1362
- case "com.amazonaws.securitylake#AccessDeniedException":
1363
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1364
- case "BadRequestException":
1365
- case "com.amazonaws.securitylake#BadRequestException":
1366
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1367
- case "ConflictException":
1368
- case "com.amazonaws.securitylake#ConflictException":
1369
- throw await de_ConflictExceptionRes(parsedOutput, context);
1370
- case "InternalServerException":
1371
- case "com.amazonaws.securitylake#InternalServerException":
1372
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1373
- case "ResourceNotFoundException":
1374
- case "com.amazonaws.securitylake#ResourceNotFoundException":
1375
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1376
- case "ThrottlingException":
1377
- case "com.amazonaws.securitylake#ThrottlingException":
1378
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1379
- default:
1380
- const parsedBody = parsedOutput.body;
1381
- return throwDefaultError({
1382
- output,
1383
- parsedBody,
1384
- errorCode,
1385
- });
1386
- }
1387
- };
1388
674
  export const de_ListLogSourcesCommand = async (output, context) => {
1389
675
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1390
- return de_ListLogSourcesCommandError(output, context);
676
+ return de_CommandError(output, context);
1391
677
  }
1392
678
  const contents = map({
1393
679
  $metadata: deserializeMetadata(output),
@@ -1400,43 +686,9 @@ export const de_ListLogSourcesCommand = async (output, context) => {
1400
686
  Object.assign(contents, doc);
1401
687
  return contents;
1402
688
  };
1403
- const de_ListLogSourcesCommandError = async (output, context) => {
1404
- const parsedOutput = {
1405
- ...output,
1406
- body: await parseErrorBody(output.body, context),
1407
- };
1408
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1409
- switch (errorCode) {
1410
- case "AccessDeniedException":
1411
- case "com.amazonaws.securitylake#AccessDeniedException":
1412
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1413
- case "BadRequestException":
1414
- case "com.amazonaws.securitylake#BadRequestException":
1415
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1416
- case "ConflictException":
1417
- case "com.amazonaws.securitylake#ConflictException":
1418
- throw await de_ConflictExceptionRes(parsedOutput, context);
1419
- case "InternalServerException":
1420
- case "com.amazonaws.securitylake#InternalServerException":
1421
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1422
- case "ResourceNotFoundException":
1423
- case "com.amazonaws.securitylake#ResourceNotFoundException":
1424
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1425
- case "ThrottlingException":
1426
- case "com.amazonaws.securitylake#ThrottlingException":
1427
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1428
- default:
1429
- const parsedBody = parsedOutput.body;
1430
- return throwDefaultError({
1431
- output,
1432
- parsedBody,
1433
- errorCode,
1434
- });
1435
- }
1436
- };
1437
689
  export const de_ListSubscribersCommand = async (output, context) => {
1438
690
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1439
- return de_ListSubscribersCommandError(output, context);
691
+ return de_CommandError(output, context);
1440
692
  }
1441
693
  const contents = map({
1442
694
  $metadata: deserializeMetadata(output),
@@ -1449,43 +701,9 @@ export const de_ListSubscribersCommand = async (output, context) => {
1449
701
  Object.assign(contents, doc);
1450
702
  return contents;
1451
703
  };
1452
- const de_ListSubscribersCommandError = async (output, context) => {
1453
- const parsedOutput = {
1454
- ...output,
1455
- body: await parseErrorBody(output.body, context),
1456
- };
1457
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1458
- switch (errorCode) {
1459
- case "AccessDeniedException":
1460
- case "com.amazonaws.securitylake#AccessDeniedException":
1461
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1462
- case "BadRequestException":
1463
- case "com.amazonaws.securitylake#BadRequestException":
1464
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1465
- case "ConflictException":
1466
- case "com.amazonaws.securitylake#ConflictException":
1467
- throw await de_ConflictExceptionRes(parsedOutput, context);
1468
- case "InternalServerException":
1469
- case "com.amazonaws.securitylake#InternalServerException":
1470
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1471
- case "ResourceNotFoundException":
1472
- case "com.amazonaws.securitylake#ResourceNotFoundException":
1473
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1474
- case "ThrottlingException":
1475
- case "com.amazonaws.securitylake#ThrottlingException":
1476
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1477
- default:
1478
- const parsedBody = parsedOutput.body;
1479
- return throwDefaultError({
1480
- output,
1481
- parsedBody,
1482
- errorCode,
1483
- });
1484
- }
1485
- };
1486
704
  export const de_ListTagsForResourceCommand = async (output, context) => {
1487
705
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1488
- return de_ListTagsForResourceCommandError(output, context);
706
+ return de_CommandError(output, context);
1489
707
  }
1490
708
  const contents = map({
1491
709
  $metadata: deserializeMetadata(output),
@@ -1497,43 +715,9 @@ export const de_ListTagsForResourceCommand = async (output, context) => {
1497
715
  Object.assign(contents, doc);
1498
716
  return contents;
1499
717
  };
1500
- const de_ListTagsForResourceCommandError = async (output, context) => {
1501
- const parsedOutput = {
1502
- ...output,
1503
- body: await parseErrorBody(output.body, context),
1504
- };
1505
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1506
- switch (errorCode) {
1507
- case "AccessDeniedException":
1508
- case "com.amazonaws.securitylake#AccessDeniedException":
1509
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1510
- case "BadRequestException":
1511
- case "com.amazonaws.securitylake#BadRequestException":
1512
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1513
- case "ConflictException":
1514
- case "com.amazonaws.securitylake#ConflictException":
1515
- throw await de_ConflictExceptionRes(parsedOutput, context);
1516
- case "InternalServerException":
1517
- case "com.amazonaws.securitylake#InternalServerException":
1518
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1519
- case "ResourceNotFoundException":
1520
- case "com.amazonaws.securitylake#ResourceNotFoundException":
1521
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1522
- case "ThrottlingException":
1523
- case "com.amazonaws.securitylake#ThrottlingException":
1524
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1525
- default:
1526
- const parsedBody = parsedOutput.body;
1527
- return throwDefaultError({
1528
- output,
1529
- parsedBody,
1530
- errorCode,
1531
- });
1532
- }
1533
- };
1534
718
  export const de_RegisterDataLakeDelegatedAdministratorCommand = async (output, context) => {
1535
719
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1536
- return de_RegisterDataLakeDelegatedAdministratorCommandError(output, context);
720
+ return de_CommandError(output, context);
1537
721
  }
1538
722
  const contents = map({
1539
723
  $metadata: deserializeMetadata(output),
@@ -1541,43 +725,9 @@ export const de_RegisterDataLakeDelegatedAdministratorCommand = async (output, c
1541
725
  await collectBody(output.body, context);
1542
726
  return contents;
1543
727
  };
1544
- const de_RegisterDataLakeDelegatedAdministratorCommandError = async (output, context) => {
1545
- const parsedOutput = {
1546
- ...output,
1547
- body: await parseErrorBody(output.body, context),
1548
- };
1549
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1550
- switch (errorCode) {
1551
- case "AccessDeniedException":
1552
- case "com.amazonaws.securitylake#AccessDeniedException":
1553
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1554
- case "BadRequestException":
1555
- case "com.amazonaws.securitylake#BadRequestException":
1556
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1557
- case "ConflictException":
1558
- case "com.amazonaws.securitylake#ConflictException":
1559
- throw await de_ConflictExceptionRes(parsedOutput, context);
1560
- case "InternalServerException":
1561
- case "com.amazonaws.securitylake#InternalServerException":
1562
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1563
- case "ResourceNotFoundException":
1564
- case "com.amazonaws.securitylake#ResourceNotFoundException":
1565
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1566
- case "ThrottlingException":
1567
- case "com.amazonaws.securitylake#ThrottlingException":
1568
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1569
- default:
1570
- const parsedBody = parsedOutput.body;
1571
- return throwDefaultError({
1572
- output,
1573
- parsedBody,
1574
- errorCode,
1575
- });
1576
- }
1577
- };
1578
728
  export const de_TagResourceCommand = async (output, context) => {
1579
729
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1580
- return de_TagResourceCommandError(output, context);
730
+ return de_CommandError(output, context);
1581
731
  }
1582
732
  const contents = map({
1583
733
  $metadata: deserializeMetadata(output),
@@ -1585,43 +735,9 @@ export const de_TagResourceCommand = async (output, context) => {
1585
735
  await collectBody(output.body, context);
1586
736
  return contents;
1587
737
  };
1588
- const de_TagResourceCommandError = async (output, context) => {
1589
- const parsedOutput = {
1590
- ...output,
1591
- body: await parseErrorBody(output.body, context),
1592
- };
1593
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1594
- switch (errorCode) {
1595
- case "AccessDeniedException":
1596
- case "com.amazonaws.securitylake#AccessDeniedException":
1597
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1598
- case "BadRequestException":
1599
- case "com.amazonaws.securitylake#BadRequestException":
1600
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1601
- case "ConflictException":
1602
- case "com.amazonaws.securitylake#ConflictException":
1603
- throw await de_ConflictExceptionRes(parsedOutput, context);
1604
- case "InternalServerException":
1605
- case "com.amazonaws.securitylake#InternalServerException":
1606
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1607
- case "ResourceNotFoundException":
1608
- case "com.amazonaws.securitylake#ResourceNotFoundException":
1609
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1610
- case "ThrottlingException":
1611
- case "com.amazonaws.securitylake#ThrottlingException":
1612
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1613
- default:
1614
- const parsedBody = parsedOutput.body;
1615
- return throwDefaultError({
1616
- output,
1617
- parsedBody,
1618
- errorCode,
1619
- });
1620
- }
1621
- };
1622
738
  export const de_UntagResourceCommand = async (output, context) => {
1623
739
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1624
- return de_UntagResourceCommandError(output, context);
740
+ return de_CommandError(output, context);
1625
741
  }
1626
742
  const contents = map({
1627
743
  $metadata: deserializeMetadata(output),
@@ -1629,43 +745,9 @@ export const de_UntagResourceCommand = async (output, context) => {
1629
745
  await collectBody(output.body, context);
1630
746
  return contents;
1631
747
  };
1632
- const de_UntagResourceCommandError = async (output, context) => {
1633
- const parsedOutput = {
1634
- ...output,
1635
- body: await parseErrorBody(output.body, context),
1636
- };
1637
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1638
- switch (errorCode) {
1639
- case "AccessDeniedException":
1640
- case "com.amazonaws.securitylake#AccessDeniedException":
1641
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1642
- case "BadRequestException":
1643
- case "com.amazonaws.securitylake#BadRequestException":
1644
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1645
- case "ConflictException":
1646
- case "com.amazonaws.securitylake#ConflictException":
1647
- throw await de_ConflictExceptionRes(parsedOutput, context);
1648
- case "InternalServerException":
1649
- case "com.amazonaws.securitylake#InternalServerException":
1650
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1651
- case "ResourceNotFoundException":
1652
- case "com.amazonaws.securitylake#ResourceNotFoundException":
1653
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1654
- case "ThrottlingException":
1655
- case "com.amazonaws.securitylake#ThrottlingException":
1656
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1657
- default:
1658
- const parsedBody = parsedOutput.body;
1659
- return throwDefaultError({
1660
- output,
1661
- parsedBody,
1662
- errorCode,
1663
- });
1664
- }
1665
- };
1666
748
  export const de_UpdateDataLakeCommand = async (output, context) => {
1667
749
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1668
- return de_UpdateDataLakeCommandError(output, context);
750
+ return de_CommandError(output, context);
1669
751
  }
1670
752
  const contents = map({
1671
753
  $metadata: deserializeMetadata(output),
@@ -1677,43 +759,9 @@ export const de_UpdateDataLakeCommand = async (output, context) => {
1677
759
  Object.assign(contents, doc);
1678
760
  return contents;
1679
761
  };
1680
- const de_UpdateDataLakeCommandError = async (output, context) => {
1681
- const parsedOutput = {
1682
- ...output,
1683
- body: await parseErrorBody(output.body, context),
1684
- };
1685
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1686
- switch (errorCode) {
1687
- case "AccessDeniedException":
1688
- case "com.amazonaws.securitylake#AccessDeniedException":
1689
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1690
- case "BadRequestException":
1691
- case "com.amazonaws.securitylake#BadRequestException":
1692
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1693
- case "ConflictException":
1694
- case "com.amazonaws.securitylake#ConflictException":
1695
- throw await de_ConflictExceptionRes(parsedOutput, context);
1696
- case "InternalServerException":
1697
- case "com.amazonaws.securitylake#InternalServerException":
1698
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1699
- case "ResourceNotFoundException":
1700
- case "com.amazonaws.securitylake#ResourceNotFoundException":
1701
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1702
- case "ThrottlingException":
1703
- case "com.amazonaws.securitylake#ThrottlingException":
1704
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1705
- default:
1706
- const parsedBody = parsedOutput.body;
1707
- return throwDefaultError({
1708
- output,
1709
- parsedBody,
1710
- errorCode,
1711
- });
1712
- }
1713
- };
1714
762
  export const de_UpdateDataLakeExceptionSubscriptionCommand = async (output, context) => {
1715
763
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1716
- return de_UpdateDataLakeExceptionSubscriptionCommandError(output, context);
764
+ return de_CommandError(output, context);
1717
765
  }
1718
766
  const contents = map({
1719
767
  $metadata: deserializeMetadata(output),
@@ -1721,43 +769,9 @@ export const de_UpdateDataLakeExceptionSubscriptionCommand = async (output, cont
1721
769
  await collectBody(output.body, context);
1722
770
  return contents;
1723
771
  };
1724
- const de_UpdateDataLakeExceptionSubscriptionCommandError = async (output, context) => {
1725
- const parsedOutput = {
1726
- ...output,
1727
- body: await parseErrorBody(output.body, context),
1728
- };
1729
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1730
- switch (errorCode) {
1731
- case "AccessDeniedException":
1732
- case "com.amazonaws.securitylake#AccessDeniedException":
1733
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1734
- case "BadRequestException":
1735
- case "com.amazonaws.securitylake#BadRequestException":
1736
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1737
- case "ConflictException":
1738
- case "com.amazonaws.securitylake#ConflictException":
1739
- throw await de_ConflictExceptionRes(parsedOutput, context);
1740
- case "InternalServerException":
1741
- case "com.amazonaws.securitylake#InternalServerException":
1742
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1743
- case "ResourceNotFoundException":
1744
- case "com.amazonaws.securitylake#ResourceNotFoundException":
1745
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1746
- case "ThrottlingException":
1747
- case "com.amazonaws.securitylake#ThrottlingException":
1748
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1749
- default:
1750
- const parsedBody = parsedOutput.body;
1751
- return throwDefaultError({
1752
- output,
1753
- parsedBody,
1754
- errorCode,
1755
- });
1756
- }
1757
- };
1758
772
  export const de_UpdateSubscriberCommand = async (output, context) => {
1759
773
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1760
- return de_UpdateSubscriberCommandError(output, context);
774
+ return de_CommandError(output, context);
1761
775
  }
1762
776
  const contents = map({
1763
777
  $metadata: deserializeMetadata(output),
@@ -1769,43 +783,9 @@ export const de_UpdateSubscriberCommand = async (output, context) => {
1769
783
  Object.assign(contents, doc);
1770
784
  return contents;
1771
785
  };
1772
- const de_UpdateSubscriberCommandError = async (output, context) => {
1773
- const parsedOutput = {
1774
- ...output,
1775
- body: await parseErrorBody(output.body, context),
1776
- };
1777
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1778
- switch (errorCode) {
1779
- case "AccessDeniedException":
1780
- case "com.amazonaws.securitylake#AccessDeniedException":
1781
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1782
- case "BadRequestException":
1783
- case "com.amazonaws.securitylake#BadRequestException":
1784
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1785
- case "ConflictException":
1786
- case "com.amazonaws.securitylake#ConflictException":
1787
- throw await de_ConflictExceptionRes(parsedOutput, context);
1788
- case "InternalServerException":
1789
- case "com.amazonaws.securitylake#InternalServerException":
1790
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1791
- case "ResourceNotFoundException":
1792
- case "com.amazonaws.securitylake#ResourceNotFoundException":
1793
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1794
- case "ThrottlingException":
1795
- case "com.amazonaws.securitylake#ThrottlingException":
1796
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1797
- default:
1798
- const parsedBody = parsedOutput.body;
1799
- return throwDefaultError({
1800
- output,
1801
- parsedBody,
1802
- errorCode,
1803
- });
1804
- }
1805
- };
1806
786
  export const de_UpdateSubscriberNotificationCommand = async (output, context) => {
1807
787
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1808
- return de_UpdateSubscriberNotificationCommandError(output, context);
788
+ return de_CommandError(output, context);
1809
789
  }
1810
790
  const contents = map({
1811
791
  $metadata: deserializeMetadata(output),
@@ -1817,7 +797,7 @@ export const de_UpdateSubscriberNotificationCommand = async (output, context) =>
1817
797
  Object.assign(contents, doc);
1818
798
  return contents;
1819
799
  };
1820
- const de_UpdateSubscriberNotificationCommandError = async (output, context) => {
800
+ const de_CommandError = async (output, context) => {
1821
801
  const parsedOutput = {
1822
802
  ...output,
1823
803
  body: await parseErrorBody(output.body, context),