@aws-sdk/client-kinesis-video-archived-media 3.928.0 → 3.929.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,8 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -91,6 +90,7 @@ class KinesisVideoArchivedMediaClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -110,14 +110,14 @@ class KinesisVideoArchivedMediaClient extends smithyClient.Client {
     }
 }
 
-class KinesisVideoArchivedMediaServiceException extends smithyClient.ServiceException {
+let KinesisVideoArchivedMediaServiceException$1 = class KinesisVideoArchivedMediaServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, KinesisVideoArchivedMediaServiceException.prototype);
     }
-}
+};
 
-class ClientLimitExceededException extends KinesisVideoArchivedMediaServiceException {
+let ClientLimitExceededException$1 = class ClientLimitExceededException extends KinesisVideoArchivedMediaServiceException$1 {
     name = "ClientLimitExceededException";
     $fault = "client";
     Message;
@@ -130,12 +130,12 @@ class ClientLimitExceededException extends KinesisVideoArchivedMediaServiceExcep
         Object.setPrototypeOf(this, ClientLimitExceededException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const ClipFragmentSelectorType = {
     PRODUCER_TIMESTAMP: "PRODUCER_TIMESTAMP",
     SERVER_TIMESTAMP: "SERVER_TIMESTAMP",
 };
-class InvalidArgumentException extends KinesisVideoArchivedMediaServiceException {
+let InvalidArgumentException$1 = class InvalidArgumentException extends KinesisVideoArchivedMediaServiceException$1 {
     name = "InvalidArgumentException";
     $fault = "client";
     Message;
@@ -148,8 +148,8 @@ class InvalidArgumentException extends KinesisVideoArchivedMediaServiceException
         Object.setPrototypeOf(this, InvalidArgumentException.prototype);
         this.Message = opts.Message;
     }
-}
-class InvalidCodecPrivateDataException extends KinesisVideoArchivedMediaServiceException {
+};
+let InvalidCodecPrivateDataException$1 = class InvalidCodecPrivateDataException extends KinesisVideoArchivedMediaServiceException$1 {
     name = "InvalidCodecPrivateDataException";
     $fault = "client";
     Message;
@@ -162,8 +162,8 @@ class InvalidCodecPrivateDataException extends KinesisVideoArchivedMediaServiceE
         Object.setPrototypeOf(this, InvalidCodecPrivateDataException.prototype);
         this.Message = opts.Message;
     }
-}
-class InvalidMediaFrameException extends KinesisVideoArchivedMediaServiceException {
+};
+let InvalidMediaFrameException$1 = class InvalidMediaFrameException extends KinesisVideoArchivedMediaServiceException$1 {
     name = "InvalidMediaFrameException";
     $fault = "client";
     Message;
@@ -176,8 +176,8 @@ class InvalidMediaFrameException extends KinesisVideoArchivedMediaServiceExcepti
         Object.setPrototypeOf(this, InvalidMediaFrameException.prototype);
         this.Message = opts.Message;
     }
-}
-class MissingCodecPrivateDataException extends KinesisVideoArchivedMediaServiceException {
+};
+let MissingCodecPrivateDataException$1 = class MissingCodecPrivateDataException extends KinesisVideoArchivedMediaServiceException$1 {
     name = "MissingCodecPrivateDataException";
     $fault = "client";
     Message;
@@ -190,8 +190,8 @@ class MissingCodecPrivateDataException extends KinesisVideoArchivedMediaServiceE
         Object.setPrototypeOf(this, MissingCodecPrivateDataException.prototype);
         this.Message = opts.Message;
     }
-}
-class NoDataRetentionException extends KinesisVideoArchivedMediaServiceException {
+};
+let NoDataRetentionException$1 = class NoDataRetentionException extends KinesisVideoArchivedMediaServiceException$1 {
     name = "NoDataRetentionException";
     $fault = "client";
     Message;
@@ -204,8 +204,8 @@ class NoDataRetentionException extends KinesisVideoArchivedMediaServiceException
         Object.setPrototypeOf(this, NoDataRetentionException.prototype);
         this.Message = opts.Message;
     }
-}
-class NotAuthorizedException extends KinesisVideoArchivedMediaServiceException {
+};
+let NotAuthorizedException$1 = class NotAuthorizedException extends KinesisVideoArchivedMediaServiceException$1 {
     name = "NotAuthorizedException";
     $fault = "client";
     Message;
@@ -218,8 +218,8 @@ class NotAuthorizedException extends KinesisVideoArchivedMediaServiceException {
         Object.setPrototypeOf(this, NotAuthorizedException.prototype);
         this.Message = opts.Message;
     }
-}
-class ResourceNotFoundException extends KinesisVideoArchivedMediaServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends KinesisVideoArchivedMediaServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     Message;
@@ -232,8 +232,8 @@ class ResourceNotFoundException extends KinesisVideoArchivedMediaServiceExceptio
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
         this.Message = opts.Message;
     }
-}
-class UnsupportedStreamMediaTypeException extends KinesisVideoArchivedMediaServiceException {
+};
+let UnsupportedStreamMediaTypeException$1 = class UnsupportedStreamMediaTypeException extends KinesisVideoArchivedMediaServiceException$1 {
     name = "UnsupportedStreamMediaTypeException";
     $fault = "client";
     Message;
@@ -246,7 +246,7 @@ class UnsupportedStreamMediaTypeException extends KinesisVideoArchivedMediaServi
         Object.setPrototypeOf(this, UnsupportedStreamMediaTypeException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const DASHFragmentSelectorType = {
     PRODUCER_TIMESTAMP: "PRODUCER_TIMESTAMP",
     SERVER_TIMESTAMP: "SERVER_TIMESTAMP",
@@ -305,473 +305,382 @@ const FragmentSelectorType = {
     PRODUCER_TIMESTAMP: "PRODUCER_TIMESTAMP",
     SERVER_TIMESTAMP: "SERVER_TIMESTAMP",
 };
-const GetClipOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-const GetMediaForFragmentListOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
 
-const se_GetClipCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/getClip");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ClipFragmentSelector: (_) => se_ClipFragmentSelector(_),
-        StreamARN: [],
-        StreamName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetDASHStreamingSessionURLCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/getDASHStreamingSessionURL");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        DASHFragmentSelector: (_) => se_DASHFragmentSelector(_),
-        DisplayFragmentNumber: [],
-        DisplayFragmentTimestamp: [],
-        Expires: [],
-        MaxManifestFragmentResults: [],
-        PlaybackMode: [],
-        StreamARN: [],
-        StreamName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetHLSStreamingSessionURLCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/getHLSStreamingSessionURL");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ContainerFormat: [],
-        DiscontinuityMode: [],
-        DisplayFragmentTimestamp: [],
-        Expires: [],
-        HLSFragmentSelector: (_) => se_HLSFragmentSelector(_),
-        MaxMediaPlaylistFragmentResults: [],
-        PlaybackMode: [],
-        StreamARN: [],
-        StreamName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetImagesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/getImages");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        EndTimestamp: (_) => _.getTime() / 1_000,
-        Format: [],
-        FormatConfig: (_) => smithyClient._json(_),
-        HeightPixels: [],
-        ImageSelectorType: [],
-        MaxResults: [],
-        NextToken: [],
-        SamplingInterval: [],
-        StartTimestamp: (_) => _.getTime() / 1_000,
-        StreamARN: [],
-        StreamName: [],
-        WidthPixels: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetMediaForFragmentListCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/getMediaForFragmentList");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Fragments: (_) => smithyClient._json(_),
-        StreamARN: [],
-        StreamName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListFragmentsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/listFragments");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        FragmentSelector: (_) => se_FragmentSelector(_),
-        MaxResults: [],
-        NextToken: [],
-        StreamARN: [],
-        StreamName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const de_GetClipCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_CT]: [, output.headers[_ct]],
-    });
-    const data = output.body;
-    context.sdkStreamMixin(data);
-    contents.Payload = data;
-    return contents;
-};
-const de_GetDASHStreamingSessionURLCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        DASHStreamingSessionURL: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetHLSStreamingSessionURLCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        HLSStreamingSessionURL: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetImagesCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Images: (_) => de_Images(_),
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetMediaForFragmentListCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_CT]: [, output.headers[_ct]],
-    });
-    const data = output.body;
-    context.sdkStreamMixin(data);
-    contents.Payload = data;
-    return contents;
-};
-const de_ListFragmentsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Fragments: (_) => de_FragmentList(_),
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientLimitExceededException":
-        case "com.amazonaws.kinesisvideoarchivedmedia#ClientLimitExceededException":
-            throw await de_ClientLimitExceededExceptionRes(parsedOutput);
-        case "InvalidArgumentException":
-        case "com.amazonaws.kinesisvideoarchivedmedia#InvalidArgumentException":
-            throw await de_InvalidArgumentExceptionRes(parsedOutput);
-        case "InvalidCodecPrivateDataException":
-        case "com.amazonaws.kinesisvideoarchivedmedia#InvalidCodecPrivateDataException":
-            throw await de_InvalidCodecPrivateDataExceptionRes(parsedOutput);
-        case "InvalidMediaFrameException":
-        case "com.amazonaws.kinesisvideoarchivedmedia#InvalidMediaFrameException":
-            throw await de_InvalidMediaFrameExceptionRes(parsedOutput);
-        case "MissingCodecPrivateDataException":
-        case "com.amazonaws.kinesisvideoarchivedmedia#MissingCodecPrivateDataException":
-            throw await de_MissingCodecPrivateDataExceptionRes(parsedOutput);
-        case "NoDataRetentionException":
-        case "com.amazonaws.kinesisvideoarchivedmedia#NoDataRetentionException":
-            throw await de_NoDataRetentionExceptionRes(parsedOutput);
-        case "NotAuthorizedException":
-        case "com.amazonaws.kinesisvideoarchivedmedia#NotAuthorizedException":
-            throw await de_NotAuthorizedExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.kinesisvideoarchivedmedia#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "UnsupportedStreamMediaTypeException":
-        case "com.amazonaws.kinesisvideoarchivedmedia#UnsupportedStreamMediaTypeException":
-            throw await de_UnsupportedStreamMediaTypeExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(KinesisVideoArchivedMediaServiceException);
-const de_ClientLimitExceededExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ClientLimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidArgumentExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InvalidArgumentException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidCodecPrivateDataExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InvalidCodecPrivateDataException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidMediaFrameExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InvalidMediaFrameException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_MissingCodecPrivateDataExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new MissingCodecPrivateDataException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_NoDataRetentionExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new NoDataRetentionException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_NotAuthorizedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new NotAuthorizedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_UnsupportedStreamMediaTypeExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new UnsupportedStreamMediaTypeException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const se_ClipFragmentSelector = (input, context) => {
-    return smithyClient.take(input, {
-        FragmentSelectorType: [],
-        TimestampRange: (_) => se_ClipTimestampRange(_),
-    });
-};
-const se_ClipTimestampRange = (input, context) => {
-    return smithyClient.take(input, {
-        EndTimestamp: (_) => _.getTime() / 1_000,
-        StartTimestamp: (_) => _.getTime() / 1_000,
-    });
-};
-const se_DASHFragmentSelector = (input, context) => {
-    return smithyClient.take(input, {
-        FragmentSelectorType: [],
-        TimestampRange: (_) => se_DASHTimestampRange(_),
-    });
-};
-const se_DASHTimestampRange = (input, context) => {
-    return smithyClient.take(input, {
-        EndTimestamp: (_) => _.getTime() / 1_000,
-        StartTimestamp: (_) => _.getTime() / 1_000,
-    });
-};
-const se_FragmentSelector = (input, context) => {
-    return smithyClient.take(input, {
-        FragmentSelectorType: [],
-        TimestampRange: (_) => se_TimestampRange(_),
-    });
-};
-const se_HLSFragmentSelector = (input, context) => {
-    return smithyClient.take(input, {
-        FragmentSelectorType: [],
-        TimestampRange: (_) => se_HLSTimestampRange(_),
-    });
-};
-const se_HLSTimestampRange = (input, context) => {
-    return smithyClient.take(input, {
-        EndTimestamp: (_) => _.getTime() / 1_000,
-        StartTimestamp: (_) => _.getTime() / 1_000,
-    });
-};
-const se_TimestampRange = (input, context) => {
-    return smithyClient.take(input, {
-        EndTimestamp: (_) => _.getTime() / 1_000,
-        StartTimestamp: (_) => _.getTime() / 1_000,
-    });
-};
-const de_Fragment = (output, context) => {
-    return smithyClient.take(output, {
-        FragmentLengthInMilliseconds: smithyClient.expectLong,
-        FragmentNumber: smithyClient.expectString,
-        FragmentSizeInBytes: smithyClient.expectLong,
-        ProducerTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        ServerTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_FragmentList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Fragment(entry);
-    });
-    return retVal;
-};
-const de_Image = (output, context) => {
-    return smithyClient.take(output, {
-        Error: smithyClient.expectString,
-        ImageContent: smithyClient.expectString,
-        TimeStamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_Images = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Image(entry);
-    });
-    return retVal;
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
+const _CF = "ContainerFormat";
+const _CFS = "ClipFragmentSelector";
+const _CLEE = "ClientLimitExceededException";
 const _CT = "ContentType";
-const _ct = "content-type";
+const _CTR = "ClipTimestampRange";
+const _CT_ = "Content-Type";
+const _DASHFS = "DASHFragmentSelector";
+const _DASHSSURL = "DASHStreamingSessionURL";
+const _DASHTR = "DASHTimestampRange";
+const _DFN = "DisplayFragmentNumber";
+const _DFT = "DisplayFragmentTimestamp";
+const _DM = "DiscontinuityMode";
+const _E = "Expires";
+const _ET = "EndTimestamp";
+const _Er = "Error";
+const _F = "Fragment";
+const _FC = "FormatConfig";
+const _FL = "FragmentList";
+const _FLIM = "FragmentLengthInMilliseconds";
+const _FN = "FragmentNumber";
+const _FS = "FragmentSelector";
+const _FSIB = "FragmentSizeInBytes";
+const _FST = "FragmentSelectorType";
+const _Fo = "Format";
+const _Fr = "Fragments";
+const _GC = "GetClip";
+const _GCI = "GetClipInput";
+const _GCO = "GetClipOutput";
+const _GDASHSSURL = "GetDASHStreamingSessionURL";
+const _GDASHSSURLI = "GetDASHStreamingSessionURLInput";
+const _GDASHSSURLO = "GetDASHStreamingSessionURLOutput";
+const _GHLSSSURL = "GetHLSStreamingSessionURL";
+const _GHLSSSURLI = "GetHLSStreamingSessionURLInput";
+const _GHLSSSURLO = "GetHLSStreamingSessionURLOutput";
+const _GI = "GetImages";
+const _GII = "GetImagesInput";
+const _GIO = "GetImagesOutput";
+const _GMFFL = "GetMediaForFragmentList";
+const _GMFFLI = "GetMediaForFragmentListInput";
+const _GMFFLO = "GetMediaForFragmentListOutput";
+const _HLSFS = "HLSFragmentSelector";
+const _HLSSSURL = "HLSStreamingSessionURL";
+const _HLSTR = "HLSTimestampRange";
+const _HP = "HeightPixels";
+const _I = "Images";
+const _IAE = "InvalidArgumentException";
+const _IC = "ImageContent";
+const _ICPDE = "InvalidCodecPrivateDataException";
+const _IMFE = "InvalidMediaFrameException";
+const _IST = "ImageSelectorType";
+const _Im = "Image";
+const _LF = "ListFragments";
+const _LFI = "ListFragmentsInput";
+const _LFO = "ListFragmentsOutput";
+const _M = "Message";
+const _MCPDE = "MissingCodecPrivateDataException";
+const _MMFR = "MaxManifestFragmentResults";
+const _MMPFR = "MaxMediaPlaylistFragmentResults";
+const _MR = "MaxResults";
+const _NAE = "NotAuthorizedException";
+const _NDRE = "NoDataRetentionException";
+const _NT = "NextToken";
+const _P = "Payload";
+const _PM = "PlaybackMode";
+const _PT = "ProducerTimestamp";
+const _RNFE = "ResourceNotFoundException";
+const _SARN = "StreamARN";
+const _SI = "SamplingInterval";
+const _SN = "StreamName";
+const _ST = "StartTimestamp";
+const _STe = "ServerTimestamp";
+const _TR = "TimestampRange";
+const _TS = "TimeStamp";
+const _USMTE = "UnsupportedStreamMediaTypeException";
+const _WP = "WidthPixels";
+const _c = "client";
+const _e = "error";
+const _h = "http";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _s = "streaming";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.kinesisvideoarchivedmedia";
+const n0 = "com.amazonaws.kinesisvideoarchivedmedia";
+var Payload = [
+    0,
+    n0,
+    _P,
+    {
+        [_s]: 1,
+    },
+    42,
+];
+var ClientLimitExceededException = [
+    -3,
+    n0,
+    _CLEE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ClientLimitExceededException, ClientLimitExceededException$1);
+var ClipFragmentSelector = [3, n0, _CFS, 0, [_FST, _TR], [0, () => ClipTimestampRange]];
+var ClipTimestampRange = [3, n0, _CTR, 0, [_ST, _ET], [4, 4]];
+var DASHFragmentSelector = [
+    3,
+    n0,
+    _DASHFS,
+    0,
+    [_FST, _TR],
+    [0, () => DASHTimestampRange],
+];
+var DASHTimestampRange = [3, n0, _DASHTR, 0, [_ST, _ET], [4, 4]];
+var Fragment = [3, n0, _F, 0, [_FN, _FSIB, _PT, _STe, _FLIM], [0, 1, 4, 4, 1]];
+var FragmentSelector = [3, n0, _FS, 0, [_FST, _TR], [0, () => TimestampRange]];
+var GetClipInput = [
+    3,
+    n0,
+    _GCI,
+    0,
+    [_SN, _SARN, _CFS],
+    [0, 0, () => ClipFragmentSelector],
+];
+var GetClipOutput = [
+    3,
+    n0,
+    _GCO,
+    0,
+    [_CT, _P],
+    [
+        [
+            0,
+            {
+                [_hH]: _CT_,
+            },
+        ],
+        [() => Payload, 16],
+    ],
+];
+var GetDASHStreamingSessionURLInput = [
+    3,
+    n0,
+    _GDASHSSURLI,
+    0,
+    [_SN, _SARN, _PM, _DFT, _DFN, _DASHFS, _E, _MMFR],
+    [0, 0, 0, 0, 0, () => DASHFragmentSelector, 1, 1],
+];
+var GetDASHStreamingSessionURLOutput = [3, n0, _GDASHSSURLO, 0, [_DASHSSURL], [0]];
+var GetHLSStreamingSessionURLInput = [
+    3,
+    n0,
+    _GHLSSSURLI,
+    0,
+    [_SN, _SARN, _PM, _HLSFS, _CF, _DM, _DFT, _E, _MMPFR],
+    [0, 0, 0, () => HLSFragmentSelector, 0, 0, 0, 1, 1],
+];
+var GetHLSStreamingSessionURLOutput = [3, n0, _GHLSSSURLO, 0, [_HLSSSURL], [0]];
+var GetImagesInput = [
+    3,
+    n0,
+    _GII,
+    0,
+    [_SN, _SARN, _IST, _ST, _ET, _SI, _Fo, _FC, _WP, _HP, _MR, _NT],
+    [0, 0, 0, 4, 4, 1, 0, 128 | 0, 1, 1, 1, 0],
+];
+var GetImagesOutput = [3, n0, _GIO, 0, [_I, _NT], [() => Images, 0]];
+var GetMediaForFragmentListInput = [3, n0, _GMFFLI, 0, [_SN, _SARN, _Fr], [0, 0, 64 | 0]];
+var GetMediaForFragmentListOutput = [
+    3,
+    n0,
+    _GMFFLO,
+    0,
+    [_CT, _P],
+    [
+        [
+            0,
+            {
+                [_hH]: _CT_,
+            },
+        ],
+        [() => Payload, 16],
+    ],
+];
+var HLSFragmentSelector = [3, n0, _HLSFS, 0, [_FST, _TR], [0, () => HLSTimestampRange]];
+var HLSTimestampRange = [3, n0, _HLSTR, 0, [_ST, _ET], [4, 4]];
+var Image = [3, n0, _Im, 0, [_TS, _Er, _IC], [4, 0, 0]];
+var InvalidArgumentException = [
+    -3,
+    n0,
+    _IAE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidArgumentException, InvalidArgumentException$1);
+var InvalidCodecPrivateDataException = [
+    -3,
+    n0,
+    _ICPDE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidCodecPrivateDataException, InvalidCodecPrivateDataException$1);
+var InvalidMediaFrameException = [
+    -3,
+    n0,
+    _IMFE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidMediaFrameException, InvalidMediaFrameException$1);
+var ListFragmentsInput = [
+    3,
+    n0,
+    _LFI,
+    0,
+    [_SN, _SARN, _MR, _NT, _FS],
+    [0, 0, 1, 0, () => FragmentSelector],
+];
+var ListFragmentsOutput = [3, n0, _LFO, 0, [_Fr, _NT], [() => FragmentList, 0]];
+var MissingCodecPrivateDataException = [
+    -3,
+    n0,
+    _MCPDE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(MissingCodecPrivateDataException, MissingCodecPrivateDataException$1);
+var NoDataRetentionException = [
+    -3,
+    n0,
+    _NDRE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(NoDataRetentionException, NoDataRetentionException$1);
+var NotAuthorizedException = [
+    -3,
+    n0,
+    _NAE,
+    {
+        [_e]: _c,
+        [_hE]: 401,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(NotAuthorizedException, NotAuthorizedException$1);
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var TimestampRange = [3, n0, _TR, 0, [_ST, _ET], [4, 4]];
+var UnsupportedStreamMediaTypeException = [
+    -3,
+    n0,
+    _USMTE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(UnsupportedStreamMediaTypeException, UnsupportedStreamMediaTypeException$1);
+var KinesisVideoArchivedMediaServiceException = [
+    -3,
+    _sm,
+    "KinesisVideoArchivedMediaServiceException",
+    0,
+    [],
+    [],
+];
+schema.TypeRegistry.for(_sm).registerError(KinesisVideoArchivedMediaServiceException, KinesisVideoArchivedMediaServiceException$1);
+var FragmentList = [1, n0, _FL, 0, () => Fragment];
+var Images = [1, n0, _I, 0, () => Image];
+var GetClip = [
+    9,
+    n0,
+    _GC,
+    {
+        [_h]: ["POST", "/getClip", 200],
+    },
+    () => GetClipInput,
+    () => GetClipOutput,
+];
+var GetDASHStreamingSessionURL = [
+    9,
+    n0,
+    _GDASHSSURL,
+    {
+        [_h]: ["POST", "/getDASHStreamingSessionURL", 200],
+    },
+    () => GetDASHStreamingSessionURLInput,
+    () => GetDASHStreamingSessionURLOutput,
+];
+var GetHLSStreamingSessionURL = [
+    9,
+    n0,
+    _GHLSSSURL,
+    {
+        [_h]: ["POST", "/getHLSStreamingSessionURL", 200],
+    },
+    () => GetHLSStreamingSessionURLInput,
+    () => GetHLSStreamingSessionURLOutput,
+];
+var GetImages = [
+    9,
+    n0,
+    _GI,
+    {
+        [_h]: ["POST", "/getImages", 200],
+    },
+    () => GetImagesInput,
+    () => GetImagesOutput,
+];
+var GetMediaForFragmentList = [
+    9,
+    n0,
+    _GMFFL,
+    {
+        [_h]: ["POST", "/getMediaForFragmentList", 200],
+    },
+    () => GetMediaForFragmentListInput,
+    () => GetMediaForFragmentListOutput,
+];
+var ListFragments = [
+    9,
+    n0,
+    _LF,
+    {
+        [_h]: ["POST", "/listFragments", 200],
+    },
+    () => ListFragmentsInput,
+    () => ListFragmentsOutput,
+];
 
 class GetClipCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSAcuityReader", "GetClip", {})
     .n("KinesisVideoArchivedMediaClient", "GetClipCommand")
-    .f(void 0, GetClipOutputFilterSensitiveLog)
-    .ser(se_GetClipCommand)
-    .de(de_GetClipCommand)
+    .sc(GetClip)
     .build() {
 }
 
@@ -779,16 +688,11 @@ class GetDASHStreamingSessionURLCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSAcuityReader", "GetDASHStreamingSessionURL", {})
     .n("KinesisVideoArchivedMediaClient", "GetDASHStreamingSessionURLCommand")
-    .f(void 0, void 0)
-    .ser(se_GetDASHStreamingSessionURLCommand)
-    .de(de_GetDASHStreamingSessionURLCommand)
+    .sc(GetDASHStreamingSessionURL)
     .build() {
 }
 
@@ -796,16 +700,11 @@ class GetHLSStreamingSessionURLCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSAcuityReader", "GetHLSStreamingSessionURL", {})
     .n("KinesisVideoArchivedMediaClient", "GetHLSStreamingSessionURLCommand")
-    .f(void 0, void 0)
-    .ser(se_GetHLSStreamingSessionURLCommand)
-    .de(de_GetHLSStreamingSessionURLCommand)
+    .sc(GetHLSStreamingSessionURL)
     .build() {
 }
 
@@ -813,16 +712,11 @@ class GetImagesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSAcuityReader", "GetImages", {})
     .n("KinesisVideoArchivedMediaClient", "GetImagesCommand")
-    .f(void 0, void 0)
-    .ser(se_GetImagesCommand)
-    .de(de_GetImagesCommand)
+    .sc(GetImages)
     .build() {
 }
 
@@ -830,16 +724,11 @@ class GetMediaForFragmentListCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSAcuityReader", "GetMediaForFragmentList", {})
     .n("KinesisVideoArchivedMediaClient", "GetMediaForFragmentListCommand")
-    .f(void 0, GetMediaForFragmentListOutputFilterSensitiveLog)
-    .ser(se_GetMediaForFragmentListCommand)
-    .de(de_GetMediaForFragmentListCommand)
+    .sc(GetMediaForFragmentList)
     .build() {
 }
 
@@ -847,16 +736,11 @@ class ListFragmentsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSAcuityReader", "ListFragments", {})
     .n("KinesisVideoArchivedMediaClient", "ListFragmentsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListFragmentsCommand)
-    .de(de_ListFragmentsCommand)
+    .sc(ListFragments)
     .build() {
 }
 
@@ -884,7 +768,7 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.ClientLimitExceededException = ClientLimitExceededException;
+exports.ClientLimitExceededException = ClientLimitExceededException$1;
 exports.ClipFragmentSelectorType = ClipFragmentSelectorType;
 exports.ContainerFormat = ContainerFormat;
 exports.DASHDisplayFragmentNumber = DASHDisplayFragmentNumber;
@@ -895,29 +779,27 @@ exports.Format = Format;
 exports.FormatConfigKey = FormatConfigKey;
 exports.FragmentSelectorType = FragmentSelectorType;
 exports.GetClipCommand = GetClipCommand;
-exports.GetClipOutputFilterSensitiveLog = GetClipOutputFilterSensitiveLog;
 exports.GetDASHStreamingSessionURLCommand = GetDASHStreamingSessionURLCommand;
 exports.GetHLSStreamingSessionURLCommand = GetHLSStreamingSessionURLCommand;
 exports.GetImagesCommand = GetImagesCommand;
 exports.GetMediaForFragmentListCommand = GetMediaForFragmentListCommand;
-exports.GetMediaForFragmentListOutputFilterSensitiveLog = GetMediaForFragmentListOutputFilterSensitiveLog;
 exports.HLSDiscontinuityMode = HLSDiscontinuityMode;
 exports.HLSDisplayFragmentTimestamp = HLSDisplayFragmentTimestamp;
 exports.HLSFragmentSelectorType = HLSFragmentSelectorType;
 exports.HLSPlaybackMode = HLSPlaybackMode;
 exports.ImageError = ImageError;
 exports.ImageSelectorType = ImageSelectorType;
-exports.InvalidArgumentException = InvalidArgumentException;
-exports.InvalidCodecPrivateDataException = InvalidCodecPrivateDataException;
-exports.InvalidMediaFrameException = InvalidMediaFrameException;
+exports.InvalidArgumentException = InvalidArgumentException$1;
+exports.InvalidCodecPrivateDataException = InvalidCodecPrivateDataException$1;
+exports.InvalidMediaFrameException = InvalidMediaFrameException$1;
 exports.KinesisVideoArchivedMedia = KinesisVideoArchivedMedia;
 exports.KinesisVideoArchivedMediaClient = KinesisVideoArchivedMediaClient;
-exports.KinesisVideoArchivedMediaServiceException = KinesisVideoArchivedMediaServiceException;
+exports.KinesisVideoArchivedMediaServiceException = KinesisVideoArchivedMediaServiceException$1;
 exports.ListFragmentsCommand = ListFragmentsCommand;
-exports.MissingCodecPrivateDataException = MissingCodecPrivateDataException;
-exports.NoDataRetentionException = NoDataRetentionException;
-exports.NotAuthorizedException = NotAuthorizedException;
-exports.ResourceNotFoundException = ResourceNotFoundException;
-exports.UnsupportedStreamMediaTypeException = UnsupportedStreamMediaTypeException;
+exports.MissingCodecPrivateDataException = MissingCodecPrivateDataException$1;
+exports.NoDataRetentionException = NoDataRetentionException$1;
+exports.NotAuthorizedException = NotAuthorizedException$1;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
+exports.UnsupportedStreamMediaTypeException = UnsupportedStreamMediaTypeException$1;
 exports.paginateGetImages = paginateGetImages;
 exports.paginateListFragments = paginateListFragments;