@aws-sdk/client-kafkaconnect 3.504.0 → 3.509.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 +17 -430
  2. package/dist-es/protocols/Aws_restJson1.js +16 -429
  3. package/package.json +3 -3
package/dist-cjs/index.js CHANGED
@@ -529,7 +529,7 @@ var se_UpdateConnectorCommand = /* @__PURE__ */ __name(async (input, context) =>
529
529
  }, "se_UpdateConnectorCommand");
530
530
  var de_CreateConnectorCommand = /* @__PURE__ */ __name(async (output, context) => {
531
531
  if (output.statusCode !== 200 && output.statusCode >= 300) {
532
- return de_CreateConnectorCommandError(output, context);
532
+ return de_CommandError(output, context);
533
533
  }
534
534
  const contents = (0, import_smithy_client.map)({
535
535
  $metadata: deserializeMetadata(output)
@@ -543,49 +543,9 @@ var de_CreateConnectorCommand = /* @__PURE__ */ __name(async (output, context) =
543
543
  Object.assign(contents, doc);
544
544
  return contents;
545
545
  }, "de_CreateConnectorCommand");
546
- var de_CreateConnectorCommandError = /* @__PURE__ */ __name(async (output, context) => {
547
- const parsedOutput = {
548
- ...output,
549
- body: await parseErrorBody(output.body, context)
550
- };
551
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
552
- switch (errorCode) {
553
- case "BadRequestException":
554
- case "com.amazonaws.kafkaconnect#BadRequestException":
555
- throw await de_BadRequestExceptionRes(parsedOutput, context);
556
- case "ConflictException":
557
- case "com.amazonaws.kafkaconnect#ConflictException":
558
- throw await de_ConflictExceptionRes(parsedOutput, context);
559
- case "ForbiddenException":
560
- case "com.amazonaws.kafkaconnect#ForbiddenException":
561
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
562
- case "InternalServerErrorException":
563
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
564
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
565
- case "NotFoundException":
566
- case "com.amazonaws.kafkaconnect#NotFoundException":
567
- throw await de_NotFoundExceptionRes(parsedOutput, context);
568
- case "ServiceUnavailableException":
569
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
570
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
571
- case "TooManyRequestsException":
572
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
573
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
574
- case "UnauthorizedException":
575
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
576
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
577
- default:
578
- const parsedBody = parsedOutput.body;
579
- return throwDefaultError({
580
- output,
581
- parsedBody,
582
- errorCode
583
- });
584
- }
585
- }, "de_CreateConnectorCommandError");
586
546
  var de_CreateCustomPluginCommand = /* @__PURE__ */ __name(async (output, context) => {
587
547
  if (output.statusCode !== 200 && output.statusCode >= 300) {
588
- return de_CreateCustomPluginCommandError(output, context);
548
+ return de_CommandError(output, context);
589
549
  }
590
550
  const contents = (0, import_smithy_client.map)({
591
551
  $metadata: deserializeMetadata(output)
@@ -600,49 +560,9 @@ var de_CreateCustomPluginCommand = /* @__PURE__ */ __name(async (output, context
600
560
  Object.assign(contents, doc);
601
561
  return contents;
602
562
  }, "de_CreateCustomPluginCommand");
603
- var de_CreateCustomPluginCommandError = /* @__PURE__ */ __name(async (output, context) => {
604
- const parsedOutput = {
605
- ...output,
606
- body: await parseErrorBody(output.body, context)
607
- };
608
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
609
- switch (errorCode) {
610
- case "BadRequestException":
611
- case "com.amazonaws.kafkaconnect#BadRequestException":
612
- throw await de_BadRequestExceptionRes(parsedOutput, context);
613
- case "ConflictException":
614
- case "com.amazonaws.kafkaconnect#ConflictException":
615
- throw await de_ConflictExceptionRes(parsedOutput, context);
616
- case "ForbiddenException":
617
- case "com.amazonaws.kafkaconnect#ForbiddenException":
618
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
619
- case "InternalServerErrorException":
620
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
621
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
622
- case "NotFoundException":
623
- case "com.amazonaws.kafkaconnect#NotFoundException":
624
- throw await de_NotFoundExceptionRes(parsedOutput, context);
625
- case "ServiceUnavailableException":
626
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
627
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
628
- case "TooManyRequestsException":
629
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
630
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
631
- case "UnauthorizedException":
632
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
633
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
634
- default:
635
- const parsedBody = parsedOutput.body;
636
- return throwDefaultError({
637
- output,
638
- parsedBody,
639
- errorCode
640
- });
641
- }
642
- }, "de_CreateCustomPluginCommandError");
643
563
  var de_CreateWorkerConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
644
564
  if (output.statusCode !== 200 && output.statusCode >= 300) {
645
- return de_CreateWorkerConfigurationCommandError(output, context);
565
+ return de_CommandError(output, context);
646
566
  }
647
567
  const contents = (0, import_smithy_client.map)({
648
568
  $metadata: deserializeMetadata(output)
@@ -657,49 +577,9 @@ var de_CreateWorkerConfigurationCommand = /* @__PURE__ */ __name(async (output,
657
577
  Object.assign(contents, doc);
658
578
  return contents;
659
579
  }, "de_CreateWorkerConfigurationCommand");
660
- var de_CreateWorkerConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
661
- const parsedOutput = {
662
- ...output,
663
- body: await parseErrorBody(output.body, context)
664
- };
665
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
666
- switch (errorCode) {
667
- case "BadRequestException":
668
- case "com.amazonaws.kafkaconnect#BadRequestException":
669
- throw await de_BadRequestExceptionRes(parsedOutput, context);
670
- case "ConflictException":
671
- case "com.amazonaws.kafkaconnect#ConflictException":
672
- throw await de_ConflictExceptionRes(parsedOutput, context);
673
- case "ForbiddenException":
674
- case "com.amazonaws.kafkaconnect#ForbiddenException":
675
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
676
- case "InternalServerErrorException":
677
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
678
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
679
- case "NotFoundException":
680
- case "com.amazonaws.kafkaconnect#NotFoundException":
681
- throw await de_NotFoundExceptionRes(parsedOutput, context);
682
- case "ServiceUnavailableException":
683
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
684
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
685
- case "TooManyRequestsException":
686
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
687
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
688
- case "UnauthorizedException":
689
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
690
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
691
- default:
692
- const parsedBody = parsedOutput.body;
693
- return throwDefaultError({
694
- output,
695
- parsedBody,
696
- errorCode
697
- });
698
- }
699
- }, "de_CreateWorkerConfigurationCommandError");
700
580
  var de_DeleteConnectorCommand = /* @__PURE__ */ __name(async (output, context) => {
701
581
  if (output.statusCode !== 200 && output.statusCode >= 300) {
702
- return de_DeleteConnectorCommandError(output, context);
582
+ return de_CommandError(output, context);
703
583
  }
704
584
  const contents = (0, import_smithy_client.map)({
705
585
  $metadata: deserializeMetadata(output)
@@ -712,46 +592,9 @@ var de_DeleteConnectorCommand = /* @__PURE__ */ __name(async (output, context) =
712
592
  Object.assign(contents, doc);
713
593
  return contents;
714
594
  }, "de_DeleteConnectorCommand");
715
- var de_DeleteConnectorCommandError = /* @__PURE__ */ __name(async (output, context) => {
716
- const parsedOutput = {
717
- ...output,
718
- body: await parseErrorBody(output.body, context)
719
- };
720
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
721
- switch (errorCode) {
722
- case "BadRequestException":
723
- case "com.amazonaws.kafkaconnect#BadRequestException":
724
- throw await de_BadRequestExceptionRes(parsedOutput, context);
725
- case "ForbiddenException":
726
- case "com.amazonaws.kafkaconnect#ForbiddenException":
727
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
728
- case "InternalServerErrorException":
729
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
730
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
731
- case "NotFoundException":
732
- case "com.amazonaws.kafkaconnect#NotFoundException":
733
- throw await de_NotFoundExceptionRes(parsedOutput, context);
734
- case "ServiceUnavailableException":
735
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
736
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
737
- case "TooManyRequestsException":
738
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
739
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
740
- case "UnauthorizedException":
741
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
742
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
743
- default:
744
- const parsedBody = parsedOutput.body;
745
- return throwDefaultError({
746
- output,
747
- parsedBody,
748
- errorCode
749
- });
750
- }
751
- }, "de_DeleteConnectorCommandError");
752
595
  var de_DeleteCustomPluginCommand = /* @__PURE__ */ __name(async (output, context) => {
753
596
  if (output.statusCode !== 200 && output.statusCode >= 300) {
754
- return de_DeleteCustomPluginCommandError(output, context);
597
+ return de_CommandError(output, context);
755
598
  }
756
599
  const contents = (0, import_smithy_client.map)({
757
600
  $metadata: deserializeMetadata(output)
@@ -764,46 +607,9 @@ var de_DeleteCustomPluginCommand = /* @__PURE__ */ __name(async (output, context
764
607
  Object.assign(contents, doc);
765
608
  return contents;
766
609
  }, "de_DeleteCustomPluginCommand");
767
- var de_DeleteCustomPluginCommandError = /* @__PURE__ */ __name(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 "BadRequestException":
775
- case "com.amazonaws.kafkaconnect#BadRequestException":
776
- throw await de_BadRequestExceptionRes(parsedOutput, context);
777
- case "ForbiddenException":
778
- case "com.amazonaws.kafkaconnect#ForbiddenException":
779
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
780
- case "InternalServerErrorException":
781
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
782
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
783
- case "NotFoundException":
784
- case "com.amazonaws.kafkaconnect#NotFoundException":
785
- throw await de_NotFoundExceptionRes(parsedOutput, context);
786
- case "ServiceUnavailableException":
787
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
788
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
789
- case "TooManyRequestsException":
790
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
791
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
792
- case "UnauthorizedException":
793
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
794
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
795
- default:
796
- const parsedBody = parsedOutput.body;
797
- return throwDefaultError({
798
- output,
799
- parsedBody,
800
- errorCode
801
- });
802
- }
803
- }, "de_DeleteCustomPluginCommandError");
804
610
  var de_DescribeConnectorCommand = /* @__PURE__ */ __name(async (output, context) => {
805
611
  if (output.statusCode !== 200 && output.statusCode >= 300) {
806
- return de_DescribeConnectorCommandError(output, context);
612
+ return de_CommandError(output, context);
807
613
  }
808
614
  const contents = (0, import_smithy_client.map)({
809
615
  $metadata: deserializeMetadata(output)
@@ -831,46 +637,9 @@ var de_DescribeConnectorCommand = /* @__PURE__ */ __name(async (output, context)
831
637
  Object.assign(contents, doc);
832
638
  return contents;
833
639
  }, "de_DescribeConnectorCommand");
834
- var de_DescribeConnectorCommandError = /* @__PURE__ */ __name(async (output, context) => {
835
- const parsedOutput = {
836
- ...output,
837
- body: await parseErrorBody(output.body, context)
838
- };
839
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
840
- switch (errorCode) {
841
- case "BadRequestException":
842
- case "com.amazonaws.kafkaconnect#BadRequestException":
843
- throw await de_BadRequestExceptionRes(parsedOutput, context);
844
- case "ForbiddenException":
845
- case "com.amazonaws.kafkaconnect#ForbiddenException":
846
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
847
- case "InternalServerErrorException":
848
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
849
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
850
- case "NotFoundException":
851
- case "com.amazonaws.kafkaconnect#NotFoundException":
852
- throw await de_NotFoundExceptionRes(parsedOutput, context);
853
- case "ServiceUnavailableException":
854
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
855
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
856
- case "TooManyRequestsException":
857
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
858
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
859
- case "UnauthorizedException":
860
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
861
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
862
- default:
863
- const parsedBody = parsedOutput.body;
864
- return throwDefaultError({
865
- output,
866
- parsedBody,
867
- errorCode
868
- });
869
- }
870
- }, "de_DescribeConnectorCommandError");
871
640
  var de_DescribeCustomPluginCommand = /* @__PURE__ */ __name(async (output, context) => {
872
641
  if (output.statusCode !== 200 && output.statusCode >= 300) {
873
- return de_DescribeCustomPluginCommandError(output, context);
642
+ return de_CommandError(output, context);
874
643
  }
875
644
  const contents = (0, import_smithy_client.map)({
876
645
  $metadata: deserializeMetadata(output)
@@ -888,46 +657,9 @@ var de_DescribeCustomPluginCommand = /* @__PURE__ */ __name(async (output, conte
888
657
  Object.assign(contents, doc);
889
658
  return contents;
890
659
  }, "de_DescribeCustomPluginCommand");
891
- var de_DescribeCustomPluginCommandError = /* @__PURE__ */ __name(async (output, context) => {
892
- const parsedOutput = {
893
- ...output,
894
- body: await parseErrorBody(output.body, context)
895
- };
896
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
897
- switch (errorCode) {
898
- case "BadRequestException":
899
- case "com.amazonaws.kafkaconnect#BadRequestException":
900
- throw await de_BadRequestExceptionRes(parsedOutput, context);
901
- case "ForbiddenException":
902
- case "com.amazonaws.kafkaconnect#ForbiddenException":
903
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
904
- case "InternalServerErrorException":
905
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
906
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
907
- case "NotFoundException":
908
- case "com.amazonaws.kafkaconnect#NotFoundException":
909
- throw await de_NotFoundExceptionRes(parsedOutput, context);
910
- case "ServiceUnavailableException":
911
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
912
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
913
- case "TooManyRequestsException":
914
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
915
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
916
- case "UnauthorizedException":
917
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
918
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
919
- default:
920
- const parsedBody = parsedOutput.body;
921
- return throwDefaultError({
922
- output,
923
- parsedBody,
924
- errorCode
925
- });
926
- }
927
- }, "de_DescribeCustomPluginCommandError");
928
660
  var de_DescribeWorkerConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
929
661
  if (output.statusCode !== 200 && output.statusCode >= 300) {
930
- return de_DescribeWorkerConfigurationCommandError(output, context);
662
+ return de_CommandError(output, context);
931
663
  }
932
664
  const contents = (0, import_smithy_client.map)({
933
665
  $metadata: deserializeMetadata(output)
@@ -943,46 +675,9 @@ var de_DescribeWorkerConfigurationCommand = /* @__PURE__ */ __name(async (output
943
675
  Object.assign(contents, doc);
944
676
  return contents;
945
677
  }, "de_DescribeWorkerConfigurationCommand");
946
- var de_DescribeWorkerConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
947
- const parsedOutput = {
948
- ...output,
949
- body: await parseErrorBody(output.body, context)
950
- };
951
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
952
- switch (errorCode) {
953
- case "BadRequestException":
954
- case "com.amazonaws.kafkaconnect#BadRequestException":
955
- throw await de_BadRequestExceptionRes(parsedOutput, context);
956
- case "ForbiddenException":
957
- case "com.amazonaws.kafkaconnect#ForbiddenException":
958
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
959
- case "InternalServerErrorException":
960
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
961
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
962
- case "NotFoundException":
963
- case "com.amazonaws.kafkaconnect#NotFoundException":
964
- throw await de_NotFoundExceptionRes(parsedOutput, context);
965
- case "ServiceUnavailableException":
966
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
967
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
968
- case "TooManyRequestsException":
969
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
970
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
971
- case "UnauthorizedException":
972
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
973
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
974
- default:
975
- const parsedBody = parsedOutput.body;
976
- return throwDefaultError({
977
- output,
978
- parsedBody,
979
- errorCode
980
- });
981
- }
982
- }, "de_DescribeWorkerConfigurationCommandError");
983
678
  var de_ListConnectorsCommand = /* @__PURE__ */ __name(async (output, context) => {
984
679
  if (output.statusCode !== 200 && output.statusCode >= 300) {
985
- return de_ListConnectorsCommandError(output, context);
680
+ return de_CommandError(output, context);
986
681
  }
987
682
  const contents = (0, import_smithy_client.map)({
988
683
  $metadata: deserializeMetadata(output)
@@ -995,46 +690,9 @@ var de_ListConnectorsCommand = /* @__PURE__ */ __name(async (output, context) =>
995
690
  Object.assign(contents, doc);
996
691
  return contents;
997
692
  }, "de_ListConnectorsCommand");
998
- var de_ListConnectorsCommandError = /* @__PURE__ */ __name(async (output, context) => {
999
- const parsedOutput = {
1000
- ...output,
1001
- body: await parseErrorBody(output.body, context)
1002
- };
1003
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1004
- switch (errorCode) {
1005
- case "BadRequestException":
1006
- case "com.amazonaws.kafkaconnect#BadRequestException":
1007
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1008
- case "ForbiddenException":
1009
- case "com.amazonaws.kafkaconnect#ForbiddenException":
1010
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
1011
- case "InternalServerErrorException":
1012
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
1013
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
1014
- case "NotFoundException":
1015
- case "com.amazonaws.kafkaconnect#NotFoundException":
1016
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1017
- case "ServiceUnavailableException":
1018
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
1019
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1020
- case "TooManyRequestsException":
1021
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
1022
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1023
- case "UnauthorizedException":
1024
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
1025
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1026
- default:
1027
- const parsedBody = parsedOutput.body;
1028
- return throwDefaultError({
1029
- output,
1030
- parsedBody,
1031
- errorCode
1032
- });
1033
- }
1034
- }, "de_ListConnectorsCommandError");
1035
693
  var de_ListCustomPluginsCommand = /* @__PURE__ */ __name(async (output, context) => {
1036
694
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1037
- return de_ListCustomPluginsCommandError(output, context);
695
+ return de_CommandError(output, context);
1038
696
  }
1039
697
  const contents = (0, import_smithy_client.map)({
1040
698
  $metadata: deserializeMetadata(output)
@@ -1047,46 +705,9 @@ var de_ListCustomPluginsCommand = /* @__PURE__ */ __name(async (output, context)
1047
705
  Object.assign(contents, doc);
1048
706
  return contents;
1049
707
  }, "de_ListCustomPluginsCommand");
1050
- var de_ListCustomPluginsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1051
- const parsedOutput = {
1052
- ...output,
1053
- body: await parseErrorBody(output.body, context)
1054
- };
1055
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1056
- switch (errorCode) {
1057
- case "BadRequestException":
1058
- case "com.amazonaws.kafkaconnect#BadRequestException":
1059
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1060
- case "ForbiddenException":
1061
- case "com.amazonaws.kafkaconnect#ForbiddenException":
1062
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
1063
- case "InternalServerErrorException":
1064
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
1065
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
1066
- case "NotFoundException":
1067
- case "com.amazonaws.kafkaconnect#NotFoundException":
1068
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1069
- case "ServiceUnavailableException":
1070
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
1071
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1072
- case "TooManyRequestsException":
1073
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
1074
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1075
- case "UnauthorizedException":
1076
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
1077
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1078
- default:
1079
- const parsedBody = parsedOutput.body;
1080
- return throwDefaultError({
1081
- output,
1082
- parsedBody,
1083
- errorCode
1084
- });
1085
- }
1086
- }, "de_ListCustomPluginsCommandError");
1087
708
  var de_ListWorkerConfigurationsCommand = /* @__PURE__ */ __name(async (output, context) => {
1088
709
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1089
- return de_ListWorkerConfigurationsCommandError(output, context);
710
+ return de_CommandError(output, context);
1090
711
  }
1091
712
  const contents = (0, import_smithy_client.map)({
1092
713
  $metadata: deserializeMetadata(output)
@@ -1099,46 +720,9 @@ var de_ListWorkerConfigurationsCommand = /* @__PURE__ */ __name(async (output, c
1099
720
  Object.assign(contents, doc);
1100
721
  return contents;
1101
722
  }, "de_ListWorkerConfigurationsCommand");
1102
- var de_ListWorkerConfigurationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1103
- const parsedOutput = {
1104
- ...output,
1105
- body: await parseErrorBody(output.body, context)
1106
- };
1107
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1108
- switch (errorCode) {
1109
- case "BadRequestException":
1110
- case "com.amazonaws.kafkaconnect#BadRequestException":
1111
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1112
- case "ForbiddenException":
1113
- case "com.amazonaws.kafkaconnect#ForbiddenException":
1114
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
1115
- case "InternalServerErrorException":
1116
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
1117
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
1118
- case "NotFoundException":
1119
- case "com.amazonaws.kafkaconnect#NotFoundException":
1120
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1121
- case "ServiceUnavailableException":
1122
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
1123
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1124
- case "TooManyRequestsException":
1125
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
1126
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1127
- case "UnauthorizedException":
1128
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
1129
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1130
- default:
1131
- const parsedBody = parsedOutput.body;
1132
- return throwDefaultError({
1133
- output,
1134
- parsedBody,
1135
- errorCode
1136
- });
1137
- }
1138
- }, "de_ListWorkerConfigurationsCommandError");
1139
723
  var de_UpdateConnectorCommand = /* @__PURE__ */ __name(async (output, context) => {
1140
724
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1141
- return de_UpdateConnectorCommandError(output, context);
725
+ return de_CommandError(output, context);
1142
726
  }
1143
727
  const contents = (0, import_smithy_client.map)({
1144
728
  $metadata: deserializeMetadata(output)
@@ -1151,7 +735,7 @@ var de_UpdateConnectorCommand = /* @__PURE__ */ __name(async (output, context) =
1151
735
  Object.assign(contents, doc);
1152
736
  return contents;
1153
737
  }, "de_UpdateConnectorCommand");
1154
- var de_UpdateConnectorCommandError = /* @__PURE__ */ __name(async (output, context) => {
738
+ var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
1155
739
  const parsedOutput = {
1156
740
  ...output,
1157
741
  body: await parseErrorBody(output.body, context)
@@ -1161,6 +745,9 @@ var de_UpdateConnectorCommandError = /* @__PURE__ */ __name(async (output, conte
1161
745
  case "BadRequestException":
1162
746
  case "com.amazonaws.kafkaconnect#BadRequestException":
1163
747
  throw await de_BadRequestExceptionRes(parsedOutput, context);
748
+ case "ConflictException":
749
+ case "com.amazonaws.kafkaconnect#ConflictException":
750
+ throw await de_ConflictExceptionRes(parsedOutput, context);
1164
751
  case "ForbiddenException":
1165
752
  case "com.amazonaws.kafkaconnect#ForbiddenException":
1166
753
  throw await de_ForbiddenExceptionRes(parsedOutput, context);
@@ -1187,7 +774,7 @@ var de_UpdateConnectorCommandError = /* @__PURE__ */ __name(async (output, conte
1187
774
  errorCode
1188
775
  });
1189
776
  }
1190
- }, "de_UpdateConnectorCommandError");
777
+ }, "de_CommandError");
1191
778
  var throwDefaultError = (0, import_smithy_client.withBaseException)(KafkaConnectServiceException);
1192
779
  var de_BadRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1193
780
  const contents = (0, import_smithy_client.map)({});
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -161,7 +161,7 @@ export const se_UpdateConnectorCommand = async (input, context) => {
161
161
  };
162
162
  export const de_CreateConnectorCommand = async (output, context) => {
163
163
  if (output.statusCode !== 200 && output.statusCode >= 300) {
164
- return de_CreateConnectorCommandError(output, context);
164
+ return de_CommandError(output, context);
165
165
  }
166
166
  const contents = map({
167
167
  $metadata: deserializeMetadata(output),
@@ -175,49 +175,9 @@ export const de_CreateConnectorCommand = async (output, context) => {
175
175
  Object.assign(contents, doc);
176
176
  return contents;
177
177
  };
178
- const de_CreateConnectorCommandError = async (output, context) => {
179
- const parsedOutput = {
180
- ...output,
181
- body: await parseErrorBody(output.body, context),
182
- };
183
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
184
- switch (errorCode) {
185
- case "BadRequestException":
186
- case "com.amazonaws.kafkaconnect#BadRequestException":
187
- throw await de_BadRequestExceptionRes(parsedOutput, context);
188
- case "ConflictException":
189
- case "com.amazonaws.kafkaconnect#ConflictException":
190
- throw await de_ConflictExceptionRes(parsedOutput, context);
191
- case "ForbiddenException":
192
- case "com.amazonaws.kafkaconnect#ForbiddenException":
193
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
194
- case "InternalServerErrorException":
195
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
196
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
197
- case "NotFoundException":
198
- case "com.amazonaws.kafkaconnect#NotFoundException":
199
- throw await de_NotFoundExceptionRes(parsedOutput, context);
200
- case "ServiceUnavailableException":
201
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
202
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
203
- case "TooManyRequestsException":
204
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
205
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
206
- case "UnauthorizedException":
207
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
208
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
209
- default:
210
- const parsedBody = parsedOutput.body;
211
- return throwDefaultError({
212
- output,
213
- parsedBody,
214
- errorCode,
215
- });
216
- }
217
- };
218
178
  export const de_CreateCustomPluginCommand = async (output, context) => {
219
179
  if (output.statusCode !== 200 && output.statusCode >= 300) {
220
- return de_CreateCustomPluginCommandError(output, context);
180
+ return de_CommandError(output, context);
221
181
  }
222
182
  const contents = map({
223
183
  $metadata: deserializeMetadata(output),
@@ -232,49 +192,9 @@ export const de_CreateCustomPluginCommand = async (output, context) => {
232
192
  Object.assign(contents, doc);
233
193
  return contents;
234
194
  };
235
- const de_CreateCustomPluginCommandError = async (output, context) => {
236
- const parsedOutput = {
237
- ...output,
238
- body: await parseErrorBody(output.body, context),
239
- };
240
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
241
- switch (errorCode) {
242
- case "BadRequestException":
243
- case "com.amazonaws.kafkaconnect#BadRequestException":
244
- throw await de_BadRequestExceptionRes(parsedOutput, context);
245
- case "ConflictException":
246
- case "com.amazonaws.kafkaconnect#ConflictException":
247
- throw await de_ConflictExceptionRes(parsedOutput, context);
248
- case "ForbiddenException":
249
- case "com.amazonaws.kafkaconnect#ForbiddenException":
250
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
251
- case "InternalServerErrorException":
252
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
253
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
254
- case "NotFoundException":
255
- case "com.amazonaws.kafkaconnect#NotFoundException":
256
- throw await de_NotFoundExceptionRes(parsedOutput, context);
257
- case "ServiceUnavailableException":
258
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
259
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
260
- case "TooManyRequestsException":
261
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
262
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
263
- case "UnauthorizedException":
264
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
265
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
266
- default:
267
- const parsedBody = parsedOutput.body;
268
- return throwDefaultError({
269
- output,
270
- parsedBody,
271
- errorCode,
272
- });
273
- }
274
- };
275
195
  export const de_CreateWorkerConfigurationCommand = async (output, context) => {
276
196
  if (output.statusCode !== 200 && output.statusCode >= 300) {
277
- return de_CreateWorkerConfigurationCommandError(output, context);
197
+ return de_CommandError(output, context);
278
198
  }
279
199
  const contents = map({
280
200
  $metadata: deserializeMetadata(output),
@@ -289,49 +209,9 @@ export const de_CreateWorkerConfigurationCommand = async (output, context) => {
289
209
  Object.assign(contents, doc);
290
210
  return contents;
291
211
  };
292
- const de_CreateWorkerConfigurationCommandError = async (output, context) => {
293
- const parsedOutput = {
294
- ...output,
295
- body: await parseErrorBody(output.body, context),
296
- };
297
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
298
- switch (errorCode) {
299
- case "BadRequestException":
300
- case "com.amazonaws.kafkaconnect#BadRequestException":
301
- throw await de_BadRequestExceptionRes(parsedOutput, context);
302
- case "ConflictException":
303
- case "com.amazonaws.kafkaconnect#ConflictException":
304
- throw await de_ConflictExceptionRes(parsedOutput, context);
305
- case "ForbiddenException":
306
- case "com.amazonaws.kafkaconnect#ForbiddenException":
307
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
308
- case "InternalServerErrorException":
309
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
310
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
311
- case "NotFoundException":
312
- case "com.amazonaws.kafkaconnect#NotFoundException":
313
- throw await de_NotFoundExceptionRes(parsedOutput, context);
314
- case "ServiceUnavailableException":
315
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
316
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
317
- case "TooManyRequestsException":
318
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
319
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
320
- case "UnauthorizedException":
321
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
322
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
323
- default:
324
- const parsedBody = parsedOutput.body;
325
- return throwDefaultError({
326
- output,
327
- parsedBody,
328
- errorCode,
329
- });
330
- }
331
- };
332
212
  export const de_DeleteConnectorCommand = async (output, context) => {
333
213
  if (output.statusCode !== 200 && output.statusCode >= 300) {
334
- return de_DeleteConnectorCommandError(output, context);
214
+ return de_CommandError(output, context);
335
215
  }
336
216
  const contents = map({
337
217
  $metadata: deserializeMetadata(output),
@@ -344,46 +224,9 @@ export const de_DeleteConnectorCommand = async (output, context) => {
344
224
  Object.assign(contents, doc);
345
225
  return contents;
346
226
  };
347
- const de_DeleteConnectorCommandError = async (output, context) => {
348
- const parsedOutput = {
349
- ...output,
350
- body: await parseErrorBody(output.body, context),
351
- };
352
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
353
- switch (errorCode) {
354
- case "BadRequestException":
355
- case "com.amazonaws.kafkaconnect#BadRequestException":
356
- throw await de_BadRequestExceptionRes(parsedOutput, context);
357
- case "ForbiddenException":
358
- case "com.amazonaws.kafkaconnect#ForbiddenException":
359
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
360
- case "InternalServerErrorException":
361
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
362
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
363
- case "NotFoundException":
364
- case "com.amazonaws.kafkaconnect#NotFoundException":
365
- throw await de_NotFoundExceptionRes(parsedOutput, context);
366
- case "ServiceUnavailableException":
367
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
368
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
369
- case "TooManyRequestsException":
370
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
371
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
372
- case "UnauthorizedException":
373
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
374
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
375
- default:
376
- const parsedBody = parsedOutput.body;
377
- return throwDefaultError({
378
- output,
379
- parsedBody,
380
- errorCode,
381
- });
382
- }
383
- };
384
227
  export const de_DeleteCustomPluginCommand = async (output, context) => {
385
228
  if (output.statusCode !== 200 && output.statusCode >= 300) {
386
- return de_DeleteCustomPluginCommandError(output, context);
229
+ return de_CommandError(output, context);
387
230
  }
388
231
  const contents = map({
389
232
  $metadata: deserializeMetadata(output),
@@ -396,46 +239,9 @@ export const de_DeleteCustomPluginCommand = async (output, context) => {
396
239
  Object.assign(contents, doc);
397
240
  return contents;
398
241
  };
399
- const de_DeleteCustomPluginCommandError = async (output, context) => {
400
- const parsedOutput = {
401
- ...output,
402
- body: await parseErrorBody(output.body, context),
403
- };
404
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
405
- switch (errorCode) {
406
- case "BadRequestException":
407
- case "com.amazonaws.kafkaconnect#BadRequestException":
408
- throw await de_BadRequestExceptionRes(parsedOutput, context);
409
- case "ForbiddenException":
410
- case "com.amazonaws.kafkaconnect#ForbiddenException":
411
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
412
- case "InternalServerErrorException":
413
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
414
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
415
- case "NotFoundException":
416
- case "com.amazonaws.kafkaconnect#NotFoundException":
417
- throw await de_NotFoundExceptionRes(parsedOutput, context);
418
- case "ServiceUnavailableException":
419
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
420
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
421
- case "TooManyRequestsException":
422
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
423
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
424
- case "UnauthorizedException":
425
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
426
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
427
- default:
428
- const parsedBody = parsedOutput.body;
429
- return throwDefaultError({
430
- output,
431
- parsedBody,
432
- errorCode,
433
- });
434
- }
435
- };
436
242
  export const de_DescribeConnectorCommand = async (output, context) => {
437
243
  if (output.statusCode !== 200 && output.statusCode >= 300) {
438
- return de_DescribeConnectorCommandError(output, context);
244
+ return de_CommandError(output, context);
439
245
  }
440
246
  const contents = map({
441
247
  $metadata: deserializeMetadata(output),
@@ -463,46 +269,9 @@ export const de_DescribeConnectorCommand = async (output, context) => {
463
269
  Object.assign(contents, doc);
464
270
  return contents;
465
271
  };
466
- const de_DescribeConnectorCommandError = async (output, context) => {
467
- const parsedOutput = {
468
- ...output,
469
- body: await parseErrorBody(output.body, context),
470
- };
471
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
472
- switch (errorCode) {
473
- case "BadRequestException":
474
- case "com.amazonaws.kafkaconnect#BadRequestException":
475
- throw await de_BadRequestExceptionRes(parsedOutput, context);
476
- case "ForbiddenException":
477
- case "com.amazonaws.kafkaconnect#ForbiddenException":
478
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
479
- case "InternalServerErrorException":
480
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
481
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
482
- case "NotFoundException":
483
- case "com.amazonaws.kafkaconnect#NotFoundException":
484
- throw await de_NotFoundExceptionRes(parsedOutput, context);
485
- case "ServiceUnavailableException":
486
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
487
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
488
- case "TooManyRequestsException":
489
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
490
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
491
- case "UnauthorizedException":
492
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
493
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
494
- default:
495
- const parsedBody = parsedOutput.body;
496
- return throwDefaultError({
497
- output,
498
- parsedBody,
499
- errorCode,
500
- });
501
- }
502
- };
503
272
  export const de_DescribeCustomPluginCommand = async (output, context) => {
504
273
  if (output.statusCode !== 200 && output.statusCode >= 300) {
505
- return de_DescribeCustomPluginCommandError(output, context);
274
+ return de_CommandError(output, context);
506
275
  }
507
276
  const contents = map({
508
277
  $metadata: deserializeMetadata(output),
@@ -520,46 +289,9 @@ export const de_DescribeCustomPluginCommand = async (output, context) => {
520
289
  Object.assign(contents, doc);
521
290
  return contents;
522
291
  };
523
- const de_DescribeCustomPluginCommandError = async (output, context) => {
524
- const parsedOutput = {
525
- ...output,
526
- body: await parseErrorBody(output.body, context),
527
- };
528
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
529
- switch (errorCode) {
530
- case "BadRequestException":
531
- case "com.amazonaws.kafkaconnect#BadRequestException":
532
- throw await de_BadRequestExceptionRes(parsedOutput, context);
533
- case "ForbiddenException":
534
- case "com.amazonaws.kafkaconnect#ForbiddenException":
535
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
536
- case "InternalServerErrorException":
537
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
538
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
539
- case "NotFoundException":
540
- case "com.amazonaws.kafkaconnect#NotFoundException":
541
- throw await de_NotFoundExceptionRes(parsedOutput, context);
542
- case "ServiceUnavailableException":
543
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
544
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
545
- case "TooManyRequestsException":
546
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
547
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
548
- case "UnauthorizedException":
549
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
550
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
551
- default:
552
- const parsedBody = parsedOutput.body;
553
- return throwDefaultError({
554
- output,
555
- parsedBody,
556
- errorCode,
557
- });
558
- }
559
- };
560
292
  export const de_DescribeWorkerConfigurationCommand = async (output, context) => {
561
293
  if (output.statusCode !== 200 && output.statusCode >= 300) {
562
- return de_DescribeWorkerConfigurationCommandError(output, context);
294
+ return de_CommandError(output, context);
563
295
  }
564
296
  const contents = map({
565
297
  $metadata: deserializeMetadata(output),
@@ -575,46 +307,9 @@ export const de_DescribeWorkerConfigurationCommand = async (output, context) =>
575
307
  Object.assign(contents, doc);
576
308
  return contents;
577
309
  };
578
- const de_DescribeWorkerConfigurationCommandError = async (output, context) => {
579
- const parsedOutput = {
580
- ...output,
581
- body: await parseErrorBody(output.body, context),
582
- };
583
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
584
- switch (errorCode) {
585
- case "BadRequestException":
586
- case "com.amazonaws.kafkaconnect#BadRequestException":
587
- throw await de_BadRequestExceptionRes(parsedOutput, context);
588
- case "ForbiddenException":
589
- case "com.amazonaws.kafkaconnect#ForbiddenException":
590
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
591
- case "InternalServerErrorException":
592
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
593
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
594
- case "NotFoundException":
595
- case "com.amazonaws.kafkaconnect#NotFoundException":
596
- throw await de_NotFoundExceptionRes(parsedOutput, context);
597
- case "ServiceUnavailableException":
598
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
599
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
600
- case "TooManyRequestsException":
601
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
602
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
603
- case "UnauthorizedException":
604
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
605
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
606
- default:
607
- const parsedBody = parsedOutput.body;
608
- return throwDefaultError({
609
- output,
610
- parsedBody,
611
- errorCode,
612
- });
613
- }
614
- };
615
310
  export const de_ListConnectorsCommand = async (output, context) => {
616
311
  if (output.statusCode !== 200 && output.statusCode >= 300) {
617
- return de_ListConnectorsCommandError(output, context);
312
+ return de_CommandError(output, context);
618
313
  }
619
314
  const contents = map({
620
315
  $metadata: deserializeMetadata(output),
@@ -627,46 +322,9 @@ export const de_ListConnectorsCommand = async (output, context) => {
627
322
  Object.assign(contents, doc);
628
323
  return contents;
629
324
  };
630
- const de_ListConnectorsCommandError = async (output, context) => {
631
- const parsedOutput = {
632
- ...output,
633
- body: await parseErrorBody(output.body, context),
634
- };
635
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
636
- switch (errorCode) {
637
- case "BadRequestException":
638
- case "com.amazonaws.kafkaconnect#BadRequestException":
639
- throw await de_BadRequestExceptionRes(parsedOutput, context);
640
- case "ForbiddenException":
641
- case "com.amazonaws.kafkaconnect#ForbiddenException":
642
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
643
- case "InternalServerErrorException":
644
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
645
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
646
- case "NotFoundException":
647
- case "com.amazonaws.kafkaconnect#NotFoundException":
648
- throw await de_NotFoundExceptionRes(parsedOutput, context);
649
- case "ServiceUnavailableException":
650
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
651
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
652
- case "TooManyRequestsException":
653
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
654
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
655
- case "UnauthorizedException":
656
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
657
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
658
- default:
659
- const parsedBody = parsedOutput.body;
660
- return throwDefaultError({
661
- output,
662
- parsedBody,
663
- errorCode,
664
- });
665
- }
666
- };
667
325
  export const de_ListCustomPluginsCommand = async (output, context) => {
668
326
  if (output.statusCode !== 200 && output.statusCode >= 300) {
669
- return de_ListCustomPluginsCommandError(output, context);
327
+ return de_CommandError(output, context);
670
328
  }
671
329
  const contents = map({
672
330
  $metadata: deserializeMetadata(output),
@@ -679,46 +337,9 @@ export const de_ListCustomPluginsCommand = async (output, context) => {
679
337
  Object.assign(contents, doc);
680
338
  return contents;
681
339
  };
682
- const de_ListCustomPluginsCommandError = async (output, context) => {
683
- const parsedOutput = {
684
- ...output,
685
- body: await parseErrorBody(output.body, context),
686
- };
687
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
688
- switch (errorCode) {
689
- case "BadRequestException":
690
- case "com.amazonaws.kafkaconnect#BadRequestException":
691
- throw await de_BadRequestExceptionRes(parsedOutput, context);
692
- case "ForbiddenException":
693
- case "com.amazonaws.kafkaconnect#ForbiddenException":
694
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
695
- case "InternalServerErrorException":
696
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
697
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
698
- case "NotFoundException":
699
- case "com.amazonaws.kafkaconnect#NotFoundException":
700
- throw await de_NotFoundExceptionRes(parsedOutput, context);
701
- case "ServiceUnavailableException":
702
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
703
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
704
- case "TooManyRequestsException":
705
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
706
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
707
- case "UnauthorizedException":
708
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
709
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
710
- default:
711
- const parsedBody = parsedOutput.body;
712
- return throwDefaultError({
713
- output,
714
- parsedBody,
715
- errorCode,
716
- });
717
- }
718
- };
719
340
  export const de_ListWorkerConfigurationsCommand = async (output, context) => {
720
341
  if (output.statusCode !== 200 && output.statusCode >= 300) {
721
- return de_ListWorkerConfigurationsCommandError(output, context);
342
+ return de_CommandError(output, context);
722
343
  }
723
344
  const contents = map({
724
345
  $metadata: deserializeMetadata(output),
@@ -731,46 +352,9 @@ export const de_ListWorkerConfigurationsCommand = async (output, context) => {
731
352
  Object.assign(contents, doc);
732
353
  return contents;
733
354
  };
734
- const de_ListWorkerConfigurationsCommandError = async (output, context) => {
735
- const parsedOutput = {
736
- ...output,
737
- body: await parseErrorBody(output.body, context),
738
- };
739
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
740
- switch (errorCode) {
741
- case "BadRequestException":
742
- case "com.amazonaws.kafkaconnect#BadRequestException":
743
- throw await de_BadRequestExceptionRes(parsedOutput, context);
744
- case "ForbiddenException":
745
- case "com.amazonaws.kafkaconnect#ForbiddenException":
746
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
747
- case "InternalServerErrorException":
748
- case "com.amazonaws.kafkaconnect#InternalServerErrorException":
749
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
750
- case "NotFoundException":
751
- case "com.amazonaws.kafkaconnect#NotFoundException":
752
- throw await de_NotFoundExceptionRes(parsedOutput, context);
753
- case "ServiceUnavailableException":
754
- case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
755
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
756
- case "TooManyRequestsException":
757
- case "com.amazonaws.kafkaconnect#TooManyRequestsException":
758
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
759
- case "UnauthorizedException":
760
- case "com.amazonaws.kafkaconnect#UnauthorizedException":
761
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
762
- default:
763
- const parsedBody = parsedOutput.body;
764
- return throwDefaultError({
765
- output,
766
- parsedBody,
767
- errorCode,
768
- });
769
- }
770
- };
771
355
  export const de_UpdateConnectorCommand = async (output, context) => {
772
356
  if (output.statusCode !== 200 && output.statusCode >= 300) {
773
- return de_UpdateConnectorCommandError(output, context);
357
+ return de_CommandError(output, context);
774
358
  }
775
359
  const contents = map({
776
360
  $metadata: deserializeMetadata(output),
@@ -783,7 +367,7 @@ export const de_UpdateConnectorCommand = async (output, context) => {
783
367
  Object.assign(contents, doc);
784
368
  return contents;
785
369
  };
786
- const de_UpdateConnectorCommandError = async (output, context) => {
370
+ const de_CommandError = async (output, context) => {
787
371
  const parsedOutput = {
788
372
  ...output,
789
373
  body: await parseErrorBody(output.body, context),
@@ -793,6 +377,9 @@ const de_UpdateConnectorCommandError = async (output, context) => {
793
377
  case "BadRequestException":
794
378
  case "com.amazonaws.kafkaconnect#BadRequestException":
795
379
  throw await de_BadRequestExceptionRes(parsedOutput, context);
380
+ case "ConflictException":
381
+ case "com.amazonaws.kafkaconnect#ConflictException":
382
+ throw await de_ConflictExceptionRes(parsedOutput, context);
796
383
  case "ForbiddenException":
797
384
  case "com.amazonaws.kafkaconnect#ForbiddenException":
798
385
  throw await de_ForbiddenExceptionRes(parsedOutput, context);
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "@aws-sdk/client-kafkaconnect",
3
3
  "description": "AWS SDK for JavaScript Kafkaconnect Client for Node.js, Browser and React Native",
4
- "version": "3.504.0",
4
+ "version": "3.509.0",
5
5
  "scripts": {
6
6
  "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
7
7
  "build:cjs": "node ../../scripts/compilation/inline client-kafkaconnect",
@@ -20,9 +20,9 @@
20
20
  "dependencies": {
21
21
  "@aws-crypto/sha256-browser": "3.0.0",
22
22
  "@aws-crypto/sha256-js": "3.0.0",
23
- "@aws-sdk/client-sts": "3.504.0",
23
+ "@aws-sdk/client-sts": "3.507.0",
24
24
  "@aws-sdk/core": "3.496.0",
25
- "@aws-sdk/credential-provider-node": "3.504.0",
25
+ "@aws-sdk/credential-provider-node": "3.509.0",
26
26
  "@aws-sdk/middleware-host-header": "3.502.0",
27
27
  "@aws-sdk/middleware-logger": "3.502.0",
28
28
  "@aws-sdk/middleware-recursion-detection": "3.502.0",