@aws-sdk/client-kinesis-video-archived-media 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 +23 -190
  2. package/dist-es/protocols/Aws_restJson1.js +22 -189
  3. package/package.json +3 -3
package/dist-cjs/index.js CHANGED
@@ -531,7 +531,7 @@ var se_ListFragmentsCommand = /* @__PURE__ */ __name(async (input, context) => {
531
531
  }, "se_ListFragmentsCommand");
532
532
  var de_GetClipCommand = /* @__PURE__ */ __name(async (output, context) => {
533
533
  if (output.statusCode !== 200 && output.statusCode >= 300) {
534
- return de_GetClipCommandError(output, context);
534
+ return de_CommandError(output, context);
535
535
  }
536
536
  const contents = (0, import_smithy_client.map)({
537
537
  $metadata: deserializeMetadata(output),
@@ -542,52 +542,9 @@ var de_GetClipCommand = /* @__PURE__ */ __name(async (output, context) => {
542
542
  contents.Payload = data;
543
543
  return contents;
544
544
  }, "de_GetClipCommand");
545
- var de_GetClipCommandError = /* @__PURE__ */ __name(async (output, context) => {
546
- const parsedOutput = {
547
- ...output,
548
- body: await parseErrorBody(output.body, context)
549
- };
550
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
551
- switch (errorCode) {
552
- case "ClientLimitExceededException":
553
- case "com.amazonaws.kinesisvideoarchivedmedia#ClientLimitExceededException":
554
- throw await de_ClientLimitExceededExceptionRes(parsedOutput, context);
555
- case "InvalidArgumentException":
556
- case "com.amazonaws.kinesisvideoarchivedmedia#InvalidArgumentException":
557
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
558
- case "InvalidCodecPrivateDataException":
559
- case "com.amazonaws.kinesisvideoarchivedmedia#InvalidCodecPrivateDataException":
560
- throw await de_InvalidCodecPrivateDataExceptionRes(parsedOutput, context);
561
- case "InvalidMediaFrameException":
562
- case "com.amazonaws.kinesisvideoarchivedmedia#InvalidMediaFrameException":
563
- throw await de_InvalidMediaFrameExceptionRes(parsedOutput, context);
564
- case "MissingCodecPrivateDataException":
565
- case "com.amazonaws.kinesisvideoarchivedmedia#MissingCodecPrivateDataException":
566
- throw await de_MissingCodecPrivateDataExceptionRes(parsedOutput, context);
567
- case "NoDataRetentionException":
568
- case "com.amazonaws.kinesisvideoarchivedmedia#NoDataRetentionException":
569
- throw await de_NoDataRetentionExceptionRes(parsedOutput, context);
570
- case "NotAuthorizedException":
571
- case "com.amazonaws.kinesisvideoarchivedmedia#NotAuthorizedException":
572
- throw await de_NotAuthorizedExceptionRes(parsedOutput, context);
573
- case "ResourceNotFoundException":
574
- case "com.amazonaws.kinesisvideoarchivedmedia#ResourceNotFoundException":
575
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
576
- case "UnsupportedStreamMediaTypeException":
577
- case "com.amazonaws.kinesisvideoarchivedmedia#UnsupportedStreamMediaTypeException":
578
- throw await de_UnsupportedStreamMediaTypeExceptionRes(parsedOutput, context);
579
- default:
580
- const parsedBody = parsedOutput.body;
581
- return throwDefaultError({
582
- output,
583
- parsedBody,
584
- errorCode
585
- });
586
- }
587
- }, "de_GetClipCommandError");
588
545
  var de_GetDASHStreamingSessionURLCommand = /* @__PURE__ */ __name(async (output, context) => {
589
546
  if (output.statusCode !== 200 && output.statusCode >= 300) {
590
- return de_GetDASHStreamingSessionURLCommandError(output, context);
547
+ return de_CommandError(output, context);
591
548
  }
592
549
  const contents = (0, import_smithy_client.map)({
593
550
  $metadata: deserializeMetadata(output)
@@ -599,49 +556,9 @@ var de_GetDASHStreamingSessionURLCommand = /* @__PURE__ */ __name(async (output,
599
556
  Object.assign(contents, doc);
600
557
  return contents;
601
558
  }, "de_GetDASHStreamingSessionURLCommand");
602
- var de_GetDASHStreamingSessionURLCommandError = /* @__PURE__ */ __name(async (output, context) => {
603
- const parsedOutput = {
604
- ...output,
605
- body: await parseErrorBody(output.body, context)
606
- };
607
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
608
- switch (errorCode) {
609
- case "ClientLimitExceededException":
610
- case "com.amazonaws.kinesisvideoarchivedmedia#ClientLimitExceededException":
611
- throw await de_ClientLimitExceededExceptionRes(parsedOutput, context);
612
- case "InvalidArgumentException":
613
- case "com.amazonaws.kinesisvideoarchivedmedia#InvalidArgumentException":
614
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
615
- case "InvalidCodecPrivateDataException":
616
- case "com.amazonaws.kinesisvideoarchivedmedia#InvalidCodecPrivateDataException":
617
- throw await de_InvalidCodecPrivateDataExceptionRes(parsedOutput, context);
618
- case "MissingCodecPrivateDataException":
619
- case "com.amazonaws.kinesisvideoarchivedmedia#MissingCodecPrivateDataException":
620
- throw await de_MissingCodecPrivateDataExceptionRes(parsedOutput, context);
621
- case "NoDataRetentionException":
622
- case "com.amazonaws.kinesisvideoarchivedmedia#NoDataRetentionException":
623
- throw await de_NoDataRetentionExceptionRes(parsedOutput, context);
624
- case "NotAuthorizedException":
625
- case "com.amazonaws.kinesisvideoarchivedmedia#NotAuthorizedException":
626
- throw await de_NotAuthorizedExceptionRes(parsedOutput, context);
627
- case "ResourceNotFoundException":
628
- case "com.amazonaws.kinesisvideoarchivedmedia#ResourceNotFoundException":
629
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
630
- case "UnsupportedStreamMediaTypeException":
631
- case "com.amazonaws.kinesisvideoarchivedmedia#UnsupportedStreamMediaTypeException":
632
- throw await de_UnsupportedStreamMediaTypeExceptionRes(parsedOutput, context);
633
- default:
634
- const parsedBody = parsedOutput.body;
635
- return throwDefaultError({
636
- output,
637
- parsedBody,
638
- errorCode
639
- });
640
- }
641
- }, "de_GetDASHStreamingSessionURLCommandError");
642
559
  var de_GetHLSStreamingSessionURLCommand = /* @__PURE__ */ __name(async (output, context) => {
643
560
  if (output.statusCode !== 200 && output.statusCode >= 300) {
644
- return de_GetHLSStreamingSessionURLCommandError(output, context);
561
+ return de_CommandError(output, context);
645
562
  }
646
563
  const contents = (0, import_smithy_client.map)({
647
564
  $metadata: deserializeMetadata(output)
@@ -653,49 +570,9 @@ var de_GetHLSStreamingSessionURLCommand = /* @__PURE__ */ __name(async (output,
653
570
  Object.assign(contents, doc);
654
571
  return contents;
655
572
  }, "de_GetHLSStreamingSessionURLCommand");
656
- var de_GetHLSStreamingSessionURLCommandError = /* @__PURE__ */ __name(async (output, context) => {
657
- const parsedOutput = {
658
- ...output,
659
- body: await parseErrorBody(output.body, context)
660
- };
661
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
662
- switch (errorCode) {
663
- case "ClientLimitExceededException":
664
- case "com.amazonaws.kinesisvideoarchivedmedia#ClientLimitExceededException":
665
- throw await de_ClientLimitExceededExceptionRes(parsedOutput, context);
666
- case "InvalidArgumentException":
667
- case "com.amazonaws.kinesisvideoarchivedmedia#InvalidArgumentException":
668
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
669
- case "InvalidCodecPrivateDataException":
670
- case "com.amazonaws.kinesisvideoarchivedmedia#InvalidCodecPrivateDataException":
671
- throw await de_InvalidCodecPrivateDataExceptionRes(parsedOutput, context);
672
- case "MissingCodecPrivateDataException":
673
- case "com.amazonaws.kinesisvideoarchivedmedia#MissingCodecPrivateDataException":
674
- throw await de_MissingCodecPrivateDataExceptionRes(parsedOutput, context);
675
- case "NoDataRetentionException":
676
- case "com.amazonaws.kinesisvideoarchivedmedia#NoDataRetentionException":
677
- throw await de_NoDataRetentionExceptionRes(parsedOutput, context);
678
- case "NotAuthorizedException":
679
- case "com.amazonaws.kinesisvideoarchivedmedia#NotAuthorizedException":
680
- throw await de_NotAuthorizedExceptionRes(parsedOutput, context);
681
- case "ResourceNotFoundException":
682
- case "com.amazonaws.kinesisvideoarchivedmedia#ResourceNotFoundException":
683
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
684
- case "UnsupportedStreamMediaTypeException":
685
- case "com.amazonaws.kinesisvideoarchivedmedia#UnsupportedStreamMediaTypeException":
686
- throw await de_UnsupportedStreamMediaTypeExceptionRes(parsedOutput, context);
687
- default:
688
- const parsedBody = parsedOutput.body;
689
- return throwDefaultError({
690
- output,
691
- parsedBody,
692
- errorCode
693
- });
694
- }
695
- }, "de_GetHLSStreamingSessionURLCommandError");
696
573
  var de_GetImagesCommand = /* @__PURE__ */ __name(async (output, context) => {
697
574
  if (output.statusCode !== 200 && output.statusCode >= 300) {
698
- return de_GetImagesCommandError(output, context);
575
+ return de_CommandError(output, context);
699
576
  }
700
577
  const contents = (0, import_smithy_client.map)({
701
578
  $metadata: deserializeMetadata(output)
@@ -708,40 +585,9 @@ var de_GetImagesCommand = /* @__PURE__ */ __name(async (output, context) => {
708
585
  Object.assign(contents, doc);
709
586
  return contents;
710
587
  }, "de_GetImagesCommand");
711
- var de_GetImagesCommandError = /* @__PURE__ */ __name(async (output, context) => {
712
- const parsedOutput = {
713
- ...output,
714
- body: await parseErrorBody(output.body, context)
715
- };
716
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
717
- switch (errorCode) {
718
- case "ClientLimitExceededException":
719
- case "com.amazonaws.kinesisvideoarchivedmedia#ClientLimitExceededException":
720
- throw await de_ClientLimitExceededExceptionRes(parsedOutput, context);
721
- case "InvalidArgumentException":
722
- case "com.amazonaws.kinesisvideoarchivedmedia#InvalidArgumentException":
723
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
724
- case "NoDataRetentionException":
725
- case "com.amazonaws.kinesisvideoarchivedmedia#NoDataRetentionException":
726
- throw await de_NoDataRetentionExceptionRes(parsedOutput, context);
727
- case "NotAuthorizedException":
728
- case "com.amazonaws.kinesisvideoarchivedmedia#NotAuthorizedException":
729
- throw await de_NotAuthorizedExceptionRes(parsedOutput, context);
730
- case "ResourceNotFoundException":
731
- case "com.amazonaws.kinesisvideoarchivedmedia#ResourceNotFoundException":
732
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
733
- default:
734
- const parsedBody = parsedOutput.body;
735
- return throwDefaultError({
736
- output,
737
- parsedBody,
738
- errorCode
739
- });
740
- }
741
- }, "de_GetImagesCommandError");
742
588
  var de_GetMediaForFragmentListCommand = /* @__PURE__ */ __name(async (output, context) => {
743
589
  if (output.statusCode !== 200 && output.statusCode >= 300) {
744
- return de_GetMediaForFragmentListCommandError(output, context);
590
+ return de_CommandError(output, context);
745
591
  }
746
592
  const contents = (0, import_smithy_client.map)({
747
593
  $metadata: deserializeMetadata(output),
@@ -752,37 +598,9 @@ var de_GetMediaForFragmentListCommand = /* @__PURE__ */ __name(async (output, co
752
598
  contents.Payload = data;
753
599
  return contents;
754
600
  }, "de_GetMediaForFragmentListCommand");
755
- var de_GetMediaForFragmentListCommandError = /* @__PURE__ */ __name(async (output, context) => {
756
- const parsedOutput = {
757
- ...output,
758
- body: await parseErrorBody(output.body, context)
759
- };
760
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
761
- switch (errorCode) {
762
- case "ClientLimitExceededException":
763
- case "com.amazonaws.kinesisvideoarchivedmedia#ClientLimitExceededException":
764
- throw await de_ClientLimitExceededExceptionRes(parsedOutput, context);
765
- case "InvalidArgumentException":
766
- case "com.amazonaws.kinesisvideoarchivedmedia#InvalidArgumentException":
767
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
768
- case "NotAuthorizedException":
769
- case "com.amazonaws.kinesisvideoarchivedmedia#NotAuthorizedException":
770
- throw await de_NotAuthorizedExceptionRes(parsedOutput, context);
771
- case "ResourceNotFoundException":
772
- case "com.amazonaws.kinesisvideoarchivedmedia#ResourceNotFoundException":
773
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
774
- default:
775
- const parsedBody = parsedOutput.body;
776
- return throwDefaultError({
777
- output,
778
- parsedBody,
779
- errorCode
780
- });
781
- }
782
- }, "de_GetMediaForFragmentListCommandError");
783
601
  var de_ListFragmentsCommand = /* @__PURE__ */ __name(async (output, context) => {
784
602
  if (output.statusCode !== 200 && output.statusCode >= 300) {
785
- return de_ListFragmentsCommandError(output, context);
603
+ return de_CommandError(output, context);
786
604
  }
787
605
  const contents = (0, import_smithy_client.map)({
788
606
  $metadata: deserializeMetadata(output)
@@ -795,7 +613,7 @@ var de_ListFragmentsCommand = /* @__PURE__ */ __name(async (output, context) =>
795
613
  Object.assign(contents, doc);
796
614
  return contents;
797
615
  }, "de_ListFragmentsCommand");
798
- var de_ListFragmentsCommandError = /* @__PURE__ */ __name(async (output, context) => {
616
+ var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
799
617
  const parsedOutput = {
800
618
  ...output,
801
619
  body: await parseErrorBody(output.body, context)
@@ -808,12 +626,27 @@ var de_ListFragmentsCommandError = /* @__PURE__ */ __name(async (output, context
808
626
  case "InvalidArgumentException":
809
627
  case "com.amazonaws.kinesisvideoarchivedmedia#InvalidArgumentException":
810
628
  throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
629
+ case "InvalidCodecPrivateDataException":
630
+ case "com.amazonaws.kinesisvideoarchivedmedia#InvalidCodecPrivateDataException":
631
+ throw await de_InvalidCodecPrivateDataExceptionRes(parsedOutput, context);
632
+ case "InvalidMediaFrameException":
633
+ case "com.amazonaws.kinesisvideoarchivedmedia#InvalidMediaFrameException":
634
+ throw await de_InvalidMediaFrameExceptionRes(parsedOutput, context);
635
+ case "MissingCodecPrivateDataException":
636
+ case "com.amazonaws.kinesisvideoarchivedmedia#MissingCodecPrivateDataException":
637
+ throw await de_MissingCodecPrivateDataExceptionRes(parsedOutput, context);
638
+ case "NoDataRetentionException":
639
+ case "com.amazonaws.kinesisvideoarchivedmedia#NoDataRetentionException":
640
+ throw await de_NoDataRetentionExceptionRes(parsedOutput, context);
811
641
  case "NotAuthorizedException":
812
642
  case "com.amazonaws.kinesisvideoarchivedmedia#NotAuthorizedException":
813
643
  throw await de_NotAuthorizedExceptionRes(parsedOutput, context);
814
644
  case "ResourceNotFoundException":
815
645
  case "com.amazonaws.kinesisvideoarchivedmedia#ResourceNotFoundException":
816
646
  throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
647
+ case "UnsupportedStreamMediaTypeException":
648
+ case "com.amazonaws.kinesisvideoarchivedmedia#UnsupportedStreamMediaTypeException":
649
+ throw await de_UnsupportedStreamMediaTypeExceptionRes(parsedOutput, context);
817
650
  default:
818
651
  const parsedBody = parsedOutput.body;
819
652
  return throwDefaultError({
@@ -822,7 +655,7 @@ var de_ListFragmentsCommandError = /* @__PURE__ */ __name(async (output, context
822
655
  errorCode
823
656
  });
824
657
  }
825
- }, "de_ListFragmentsCommandError");
658
+ }, "de_CommandError");
826
659
  var throwDefaultError = (0, import_smithy_client.withBaseException)(KinesisVideoArchivedMediaServiceException);
827
660
  var de_ClientLimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
828
661
  const contents = (0, import_smithy_client.map)({});
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -116,7 +116,7 @@ export const se_ListFragmentsCommand = async (input, context) => {
116
116
  };
117
117
  export const de_GetClipCommand = async (output, context) => {
118
118
  if (output.statusCode !== 200 && output.statusCode >= 300) {
119
- return de_GetClipCommandError(output, context);
119
+ return de_CommandError(output, context);
120
120
  }
121
121
  const contents = map({
122
122
  $metadata: deserializeMetadata(output),
@@ -127,52 +127,9 @@ export const de_GetClipCommand = async (output, context) => {
127
127
  contents.Payload = data;
128
128
  return contents;
129
129
  };
130
- const de_GetClipCommandError = async (output, context) => {
131
- const parsedOutput = {
132
- ...output,
133
- body: await parseErrorBody(output.body, context),
134
- };
135
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
136
- switch (errorCode) {
137
- case "ClientLimitExceededException":
138
- case "com.amazonaws.kinesisvideoarchivedmedia#ClientLimitExceededException":
139
- throw await de_ClientLimitExceededExceptionRes(parsedOutput, context);
140
- case "InvalidArgumentException":
141
- case "com.amazonaws.kinesisvideoarchivedmedia#InvalidArgumentException":
142
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
143
- case "InvalidCodecPrivateDataException":
144
- case "com.amazonaws.kinesisvideoarchivedmedia#InvalidCodecPrivateDataException":
145
- throw await de_InvalidCodecPrivateDataExceptionRes(parsedOutput, context);
146
- case "InvalidMediaFrameException":
147
- case "com.amazonaws.kinesisvideoarchivedmedia#InvalidMediaFrameException":
148
- throw await de_InvalidMediaFrameExceptionRes(parsedOutput, context);
149
- case "MissingCodecPrivateDataException":
150
- case "com.amazonaws.kinesisvideoarchivedmedia#MissingCodecPrivateDataException":
151
- throw await de_MissingCodecPrivateDataExceptionRes(parsedOutput, context);
152
- case "NoDataRetentionException":
153
- case "com.amazonaws.kinesisvideoarchivedmedia#NoDataRetentionException":
154
- throw await de_NoDataRetentionExceptionRes(parsedOutput, context);
155
- case "NotAuthorizedException":
156
- case "com.amazonaws.kinesisvideoarchivedmedia#NotAuthorizedException":
157
- throw await de_NotAuthorizedExceptionRes(parsedOutput, context);
158
- case "ResourceNotFoundException":
159
- case "com.amazonaws.kinesisvideoarchivedmedia#ResourceNotFoundException":
160
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
161
- case "UnsupportedStreamMediaTypeException":
162
- case "com.amazonaws.kinesisvideoarchivedmedia#UnsupportedStreamMediaTypeException":
163
- throw await de_UnsupportedStreamMediaTypeExceptionRes(parsedOutput, context);
164
- default:
165
- const parsedBody = parsedOutput.body;
166
- return throwDefaultError({
167
- output,
168
- parsedBody,
169
- errorCode,
170
- });
171
- }
172
- };
173
130
  export const de_GetDASHStreamingSessionURLCommand = async (output, context) => {
174
131
  if (output.statusCode !== 200 && output.statusCode >= 300) {
175
- return de_GetDASHStreamingSessionURLCommandError(output, context);
132
+ return de_CommandError(output, context);
176
133
  }
177
134
  const contents = map({
178
135
  $metadata: deserializeMetadata(output),
@@ -184,49 +141,9 @@ export const de_GetDASHStreamingSessionURLCommand = async (output, context) => {
184
141
  Object.assign(contents, doc);
185
142
  return contents;
186
143
  };
187
- const de_GetDASHStreamingSessionURLCommandError = async (output, context) => {
188
- const parsedOutput = {
189
- ...output,
190
- body: await parseErrorBody(output.body, context),
191
- };
192
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
193
- switch (errorCode) {
194
- case "ClientLimitExceededException":
195
- case "com.amazonaws.kinesisvideoarchivedmedia#ClientLimitExceededException":
196
- throw await de_ClientLimitExceededExceptionRes(parsedOutput, context);
197
- case "InvalidArgumentException":
198
- case "com.amazonaws.kinesisvideoarchivedmedia#InvalidArgumentException":
199
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
200
- case "InvalidCodecPrivateDataException":
201
- case "com.amazonaws.kinesisvideoarchivedmedia#InvalidCodecPrivateDataException":
202
- throw await de_InvalidCodecPrivateDataExceptionRes(parsedOutput, context);
203
- case "MissingCodecPrivateDataException":
204
- case "com.amazonaws.kinesisvideoarchivedmedia#MissingCodecPrivateDataException":
205
- throw await de_MissingCodecPrivateDataExceptionRes(parsedOutput, context);
206
- case "NoDataRetentionException":
207
- case "com.amazonaws.kinesisvideoarchivedmedia#NoDataRetentionException":
208
- throw await de_NoDataRetentionExceptionRes(parsedOutput, context);
209
- case "NotAuthorizedException":
210
- case "com.amazonaws.kinesisvideoarchivedmedia#NotAuthorizedException":
211
- throw await de_NotAuthorizedExceptionRes(parsedOutput, context);
212
- case "ResourceNotFoundException":
213
- case "com.amazonaws.kinesisvideoarchivedmedia#ResourceNotFoundException":
214
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
215
- case "UnsupportedStreamMediaTypeException":
216
- case "com.amazonaws.kinesisvideoarchivedmedia#UnsupportedStreamMediaTypeException":
217
- throw await de_UnsupportedStreamMediaTypeExceptionRes(parsedOutput, context);
218
- default:
219
- const parsedBody = parsedOutput.body;
220
- return throwDefaultError({
221
- output,
222
- parsedBody,
223
- errorCode,
224
- });
225
- }
226
- };
227
144
  export const de_GetHLSStreamingSessionURLCommand = async (output, context) => {
228
145
  if (output.statusCode !== 200 && output.statusCode >= 300) {
229
- return de_GetHLSStreamingSessionURLCommandError(output, context);
146
+ return de_CommandError(output, context);
230
147
  }
231
148
  const contents = map({
232
149
  $metadata: deserializeMetadata(output),
@@ -238,49 +155,9 @@ export const de_GetHLSStreamingSessionURLCommand = async (output, context) => {
238
155
  Object.assign(contents, doc);
239
156
  return contents;
240
157
  };
241
- const de_GetHLSStreamingSessionURLCommandError = async (output, context) => {
242
- const parsedOutput = {
243
- ...output,
244
- body: await parseErrorBody(output.body, context),
245
- };
246
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
247
- switch (errorCode) {
248
- case "ClientLimitExceededException":
249
- case "com.amazonaws.kinesisvideoarchivedmedia#ClientLimitExceededException":
250
- throw await de_ClientLimitExceededExceptionRes(parsedOutput, context);
251
- case "InvalidArgumentException":
252
- case "com.amazonaws.kinesisvideoarchivedmedia#InvalidArgumentException":
253
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
254
- case "InvalidCodecPrivateDataException":
255
- case "com.amazonaws.kinesisvideoarchivedmedia#InvalidCodecPrivateDataException":
256
- throw await de_InvalidCodecPrivateDataExceptionRes(parsedOutput, context);
257
- case "MissingCodecPrivateDataException":
258
- case "com.amazonaws.kinesisvideoarchivedmedia#MissingCodecPrivateDataException":
259
- throw await de_MissingCodecPrivateDataExceptionRes(parsedOutput, context);
260
- case "NoDataRetentionException":
261
- case "com.amazonaws.kinesisvideoarchivedmedia#NoDataRetentionException":
262
- throw await de_NoDataRetentionExceptionRes(parsedOutput, context);
263
- case "NotAuthorizedException":
264
- case "com.amazonaws.kinesisvideoarchivedmedia#NotAuthorizedException":
265
- throw await de_NotAuthorizedExceptionRes(parsedOutput, context);
266
- case "ResourceNotFoundException":
267
- case "com.amazonaws.kinesisvideoarchivedmedia#ResourceNotFoundException":
268
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
269
- case "UnsupportedStreamMediaTypeException":
270
- case "com.amazonaws.kinesisvideoarchivedmedia#UnsupportedStreamMediaTypeException":
271
- throw await de_UnsupportedStreamMediaTypeExceptionRes(parsedOutput, context);
272
- default:
273
- const parsedBody = parsedOutput.body;
274
- return throwDefaultError({
275
- output,
276
- parsedBody,
277
- errorCode,
278
- });
279
- }
280
- };
281
158
  export const de_GetImagesCommand = async (output, context) => {
282
159
  if (output.statusCode !== 200 && output.statusCode >= 300) {
283
- return de_GetImagesCommandError(output, context);
160
+ return de_CommandError(output, context);
284
161
  }
285
162
  const contents = map({
286
163
  $metadata: deserializeMetadata(output),
@@ -293,40 +170,9 @@ export const de_GetImagesCommand = async (output, context) => {
293
170
  Object.assign(contents, doc);
294
171
  return contents;
295
172
  };
296
- const de_GetImagesCommandError = async (output, context) => {
297
- const parsedOutput = {
298
- ...output,
299
- body: await parseErrorBody(output.body, context),
300
- };
301
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
302
- switch (errorCode) {
303
- case "ClientLimitExceededException":
304
- case "com.amazonaws.kinesisvideoarchivedmedia#ClientLimitExceededException":
305
- throw await de_ClientLimitExceededExceptionRes(parsedOutput, context);
306
- case "InvalidArgumentException":
307
- case "com.amazonaws.kinesisvideoarchivedmedia#InvalidArgumentException":
308
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
309
- case "NoDataRetentionException":
310
- case "com.amazonaws.kinesisvideoarchivedmedia#NoDataRetentionException":
311
- throw await de_NoDataRetentionExceptionRes(parsedOutput, context);
312
- case "NotAuthorizedException":
313
- case "com.amazonaws.kinesisvideoarchivedmedia#NotAuthorizedException":
314
- throw await de_NotAuthorizedExceptionRes(parsedOutput, context);
315
- case "ResourceNotFoundException":
316
- case "com.amazonaws.kinesisvideoarchivedmedia#ResourceNotFoundException":
317
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
318
- default:
319
- const parsedBody = parsedOutput.body;
320
- return throwDefaultError({
321
- output,
322
- parsedBody,
323
- errorCode,
324
- });
325
- }
326
- };
327
173
  export const de_GetMediaForFragmentListCommand = async (output, context) => {
328
174
  if (output.statusCode !== 200 && output.statusCode >= 300) {
329
- return de_GetMediaForFragmentListCommandError(output, context);
175
+ return de_CommandError(output, context);
330
176
  }
331
177
  const contents = map({
332
178
  $metadata: deserializeMetadata(output),
@@ -337,37 +183,9 @@ export const de_GetMediaForFragmentListCommand = async (output, context) => {
337
183
  contents.Payload = data;
338
184
  return contents;
339
185
  };
340
- const de_GetMediaForFragmentListCommandError = async (output, context) => {
341
- const parsedOutput = {
342
- ...output,
343
- body: await parseErrorBody(output.body, context),
344
- };
345
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
346
- switch (errorCode) {
347
- case "ClientLimitExceededException":
348
- case "com.amazonaws.kinesisvideoarchivedmedia#ClientLimitExceededException":
349
- throw await de_ClientLimitExceededExceptionRes(parsedOutput, context);
350
- case "InvalidArgumentException":
351
- case "com.amazonaws.kinesisvideoarchivedmedia#InvalidArgumentException":
352
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
353
- case "NotAuthorizedException":
354
- case "com.amazonaws.kinesisvideoarchivedmedia#NotAuthorizedException":
355
- throw await de_NotAuthorizedExceptionRes(parsedOutput, context);
356
- case "ResourceNotFoundException":
357
- case "com.amazonaws.kinesisvideoarchivedmedia#ResourceNotFoundException":
358
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
359
- default:
360
- const parsedBody = parsedOutput.body;
361
- return throwDefaultError({
362
- output,
363
- parsedBody,
364
- errorCode,
365
- });
366
- }
367
- };
368
186
  export const de_ListFragmentsCommand = async (output, context) => {
369
187
  if (output.statusCode !== 200 && output.statusCode >= 300) {
370
- return de_ListFragmentsCommandError(output, context);
188
+ return de_CommandError(output, context);
371
189
  }
372
190
  const contents = map({
373
191
  $metadata: deserializeMetadata(output),
@@ -380,7 +198,7 @@ export const de_ListFragmentsCommand = async (output, context) => {
380
198
  Object.assign(contents, doc);
381
199
  return contents;
382
200
  };
383
- const de_ListFragmentsCommandError = async (output, context) => {
201
+ const de_CommandError = async (output, context) => {
384
202
  const parsedOutput = {
385
203
  ...output,
386
204
  body: await parseErrorBody(output.body, context),
@@ -393,12 +211,27 @@ const de_ListFragmentsCommandError = async (output, context) => {
393
211
  case "InvalidArgumentException":
394
212
  case "com.amazonaws.kinesisvideoarchivedmedia#InvalidArgumentException":
395
213
  throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
214
+ case "InvalidCodecPrivateDataException":
215
+ case "com.amazonaws.kinesisvideoarchivedmedia#InvalidCodecPrivateDataException":
216
+ throw await de_InvalidCodecPrivateDataExceptionRes(parsedOutput, context);
217
+ case "InvalidMediaFrameException":
218
+ case "com.amazonaws.kinesisvideoarchivedmedia#InvalidMediaFrameException":
219
+ throw await de_InvalidMediaFrameExceptionRes(parsedOutput, context);
220
+ case "MissingCodecPrivateDataException":
221
+ case "com.amazonaws.kinesisvideoarchivedmedia#MissingCodecPrivateDataException":
222
+ throw await de_MissingCodecPrivateDataExceptionRes(parsedOutput, context);
223
+ case "NoDataRetentionException":
224
+ case "com.amazonaws.kinesisvideoarchivedmedia#NoDataRetentionException":
225
+ throw await de_NoDataRetentionExceptionRes(parsedOutput, context);
396
226
  case "NotAuthorizedException":
397
227
  case "com.amazonaws.kinesisvideoarchivedmedia#NotAuthorizedException":
398
228
  throw await de_NotAuthorizedExceptionRes(parsedOutput, context);
399
229
  case "ResourceNotFoundException":
400
230
  case "com.amazonaws.kinesisvideoarchivedmedia#ResourceNotFoundException":
401
231
  throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
232
+ case "UnsupportedStreamMediaTypeException":
233
+ case "com.amazonaws.kinesisvideoarchivedmedia#UnsupportedStreamMediaTypeException":
234
+ throw await de_UnsupportedStreamMediaTypeExceptionRes(parsedOutput, context);
402
235
  default:
403
236
  const parsedBody = parsedOutput.body;
404
237
  return throwDefaultError({
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "@aws-sdk/client-kinesis-video-archived-media",
3
3
  "description": "AWS SDK for JavaScript Kinesis Video Archived Media 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-kinesis-video-archived-media",
@@ -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",