@aws-sdk/client-ivs 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 IvsClient 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 IvsClient extends smithyClient.Client {
     }
 }
 
-class IvsServiceException extends smithyClient.ServiceException {
+let IvsServiceException$1 = class IvsServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, IvsServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends IvsServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends IvsServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     exceptionMessage;
@@ -130,7 +130,7 @@ class AccessDeniedException extends IvsServiceException {
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
         this.exceptionMessage = opts.exceptionMessage;
     }
-}
+};
 const ContainerFormat = {
     FragmentedMP4: "FRAGMENTED_MP4",
     TS: "TS",
@@ -158,7 +158,7 @@ const ChannelType = {
     BasicChannelType: "BASIC",
     StandardChannelType: "STANDARD",
 };
-class PendingVerification extends IvsServiceException {
+let PendingVerification$1 = class PendingVerification extends IvsServiceException$1 {
     name = "PendingVerification";
     $fault = "client";
     exceptionMessage;
@@ -171,8 +171,8 @@ class PendingVerification extends IvsServiceException {
         Object.setPrototypeOf(this, PendingVerification.prototype);
         this.exceptionMessage = opts.exceptionMessage;
     }
-}
-class ThrottlingException extends IvsServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends IvsServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     exceptionMessage;
@@ -185,8 +185,8 @@ class ThrottlingException extends IvsServiceException {
         Object.setPrototypeOf(this, ThrottlingException.prototype);
         this.exceptionMessage = opts.exceptionMessage;
     }
-}
-class ValidationException extends IvsServiceException {
+};
+let ValidationException$1 = class ValidationException extends IvsServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     exceptionMessage;
@@ -199,8 +199,8 @@ class ValidationException extends IvsServiceException {
         Object.setPrototypeOf(this, ValidationException.prototype);
         this.exceptionMessage = opts.exceptionMessage;
     }
-}
-class ResourceNotFoundException extends IvsServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends IvsServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     exceptionMessage;
@@ -213,8 +213,8 @@ class ResourceNotFoundException extends IvsServiceException {
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
         this.exceptionMessage = opts.exceptionMessage;
     }
-}
-class ServiceQuotaExceededException extends IvsServiceException {
+};
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends IvsServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     exceptionMessage;
@@ -227,8 +227,8 @@ class ServiceQuotaExceededException extends IvsServiceException {
         Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
         this.exceptionMessage = opts.exceptionMessage;
     }
-}
-class ConflictException extends IvsServiceException {
+};
+let ConflictException$1 = class ConflictException extends IvsServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     exceptionMessage;
@@ -241,7 +241,7 @@ class ConflictException extends IvsServiceException {
         Object.setPrototypeOf(this, ConflictException.prototype);
         this.exceptionMessage = opts.exceptionMessage;
     }
-}
+};
 const RenditionConfigurationRendition = {
     FULL_HD: "FULL_HD",
     HD: "HD",
@@ -272,7 +272,7 @@ const RecordingConfigurationState = {
     CreateFailed: "CREATE_FAILED",
     Creating: "CREATING",
 };
-class InternalServerException extends IvsServiceException {
+let InternalServerException$1 = class InternalServerException extends IvsServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     exceptionMessage;
@@ -285,8 +285,8 @@ class InternalServerException extends IvsServiceException {
         Object.setPrototypeOf(this, InternalServerException.prototype);
         this.exceptionMessage = opts.exceptionMessage;
     }
-}
-class ChannelNotBroadcasting extends IvsServiceException {
+};
+let ChannelNotBroadcasting$1 = class ChannelNotBroadcasting extends IvsServiceException$1 {
     name = "ChannelNotBroadcasting";
     $fault = "client";
     exceptionMessage;
@@ -299,7 +299,7 @@ class ChannelNotBroadcasting extends IvsServiceException {
         Object.setPrototypeOf(this, ChannelNotBroadcasting.prototype);
         this.exceptionMessage = opts.exceptionMessage;
     }
-}
+};
 const StreamHealth = {
     Starving: "STARVING",
     StreamHealthy: "HEALTHY",
@@ -309,7 +309,7 @@ const StreamState = {
     StreamLive: "LIVE",
     StreamOffline: "OFFLINE",
 };
-class StreamUnavailable extends IvsServiceException {
+let StreamUnavailable$1 = class StreamUnavailable extends IvsServiceException$1 {
     name = "StreamUnavailable";
     $fault = "server";
     exceptionMessage;
@@ -322,1297 +322,1149 @@ class StreamUnavailable extends IvsServiceException {
         Object.setPrototypeOf(this, StreamUnavailable.prototype);
         this.exceptionMessage = opts.exceptionMessage;
     }
-}
-const SrtFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.passphrase && { passphrase: smithyClient.SENSITIVE_STRING }),
-});
-const ChannelFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.srt && { srt: SrtFilterSensitiveLog(obj.srt) }),
-});
-const BatchGetChannelResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.channels && { channels: obj.channels.map((item) => ChannelFilterSensitiveLog(item)) }),
-});
-const StreamKeyFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.value && { value: smithyClient.SENSITIVE_STRING }),
-});
-const BatchGetStreamKeyResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.streamKeys && { streamKeys: obj.streamKeys.map((item) => StreamKeyFilterSensitiveLog(item)) }),
-});
-const CreateChannelResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.channel && { channel: ChannelFilterSensitiveLog(obj.channel) }),
-    ...(obj.streamKey && { streamKey: StreamKeyFilterSensitiveLog(obj.streamKey) }),
-});
-const CreateStreamKeyResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.streamKey && { streamKey: StreamKeyFilterSensitiveLog(obj.streamKey) }),
-});
-const GetChannelResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.channel && { channel: ChannelFilterSensitiveLog(obj.channel) }),
-});
-const GetStreamKeyResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.streamKey && { streamKey: StreamKeyFilterSensitiveLog(obj.streamKey) }),
-});
-const StreamSessionFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.channel && { channel: ChannelFilterSensitiveLog(obj.channel) }),
-});
-const GetStreamSessionResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.streamSession && { streamSession: StreamSessionFilterSensitiveLog(obj.streamSession) }),
-});
-const PutMetadataRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.metadata && { metadata: smithyClient.SENSITIVE_STRING }),
-});
-const UpdateChannelResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.channel && { channel: ChannelFilterSensitiveLog(obj.channel) }),
-});
-
-const se_BatchGetChannelCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/BatchGetChannel");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arns: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_BatchGetStreamKeyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/BatchGetStreamKey");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arns: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_BatchStartViewerSessionRevocationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/BatchStartViewerSessionRevocation");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        viewerSessions: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateChannelCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/CreateChannel");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        authorized: [],
-        containerFormat: [],
-        insecureIngest: [],
-        latencyMode: [],
-        multitrackInputConfiguration: (_) => smithyClient._json(_),
-        name: [],
-        playbackRestrictionPolicyArn: [],
-        preset: [],
-        recordingConfigurationArn: [],
-        tags: (_) => smithyClient._json(_),
-        type: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreatePlaybackRestrictionPolicyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/CreatePlaybackRestrictionPolicy");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        allowedCountries: (_) => smithyClient._json(_),
-        allowedOrigins: (_) => smithyClient._json(_),
-        enableStrictOriginEnforcement: [],
-        name: [],
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateRecordingConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/CreateRecordingConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        destinationConfiguration: (_) => smithyClient._json(_),
-        name: [],
-        recordingReconnectWindowSeconds: [],
-        renditionConfiguration: (_) => smithyClient._json(_),
-        tags: (_) => smithyClient._json(_),
-        thumbnailConfiguration: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateStreamKeyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/CreateStreamKey");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        channelArn: [],
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteChannelCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeleteChannel");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeletePlaybackKeyPairCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeletePlaybackKeyPair");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeletePlaybackRestrictionPolicyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeletePlaybackRestrictionPolicy");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteRecordingConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeleteRecordingConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteStreamKeyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeleteStreamKey");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetChannelCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetChannel");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetPlaybackKeyPairCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetPlaybackKeyPair");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetPlaybackRestrictionPolicyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetPlaybackRestrictionPolicy");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetRecordingConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetRecordingConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetStreamCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetStream");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        channelArn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetStreamKeyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetStreamKey");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetStreamSessionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetStreamSession");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        channelArn: [],
-        streamId: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ImportPlaybackKeyPairCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ImportPlaybackKeyPair");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        name: [],
-        publicKeyMaterial: [],
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListChannelsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListChannels");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        filterByName: [],
-        filterByPlaybackRestrictionPolicyArn: [],
-        filterByRecordingConfigurationArn: [],
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListPlaybackKeyPairsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListPlaybackKeyPairs");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListPlaybackRestrictionPoliciesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListPlaybackRestrictionPolicies");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListRecordingConfigurationsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListRecordingConfigurations");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListStreamKeysCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListStreamKeys");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        channelArn: [],
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListStreamsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListStreams");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        filterBy: (_) => smithyClient._json(_),
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListStreamSessionsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListStreamSessions");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        channelArn: [],
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_PutMetadataCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/PutMetadata");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        channelArn: [],
-        metadata: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StartViewerSessionRevocationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/StartViewerSessionRevocation");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        channelArn: [],
-        viewerId: [],
-        viewerSessionVersionsLessThanOrEqualTo: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StopStreamCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/StopStream");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        channelArn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_TagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    const query = smithyClient.map({
-        [_tK]: [smithyClient.expectNonNull(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []],
-    });
-    let body;
-    b.m("DELETE").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_UpdateChannelCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/UpdateChannel");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-        authorized: [],
-        containerFormat: [],
-        insecureIngest: [],
-        latencyMode: [],
-        multitrackInputConfiguration: (_) => smithyClient._json(_),
-        name: [],
-        playbackRestrictionPolicyArn: [],
-        preset: [],
-        recordingConfigurationArn: [],
-        type: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdatePlaybackRestrictionPolicyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/UpdatePlaybackRestrictionPolicy");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        allowedCountries: (_) => smithyClient._json(_),
-        allowedOrigins: (_) => smithyClient._json(_),
-        arn: [],
-        enableStrictOriginEnforcement: [],
-        name: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const de_BatchGetChannelCommand = 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, {
-        channels: smithyClient._json,
-        errors: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_BatchGetStreamKeyCommand = 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, {
-        errors: smithyClient._json,
-        streamKeys: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_BatchStartViewerSessionRevocationCommand = 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, {
-        errors: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateChannelCommand = 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, {
-        channel: smithyClient._json,
-        streamKey: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreatePlaybackRestrictionPolicyCommand = 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, {
-        playbackRestrictionPolicy: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateRecordingConfigurationCommand = 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, {
-        recordingConfiguration: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateStreamKeyCommand = 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, {
-        streamKey: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteChannelCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DeletePlaybackKeyPairCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DeletePlaybackRestrictionPolicyCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DeleteRecordingConfigurationCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DeleteStreamKeyCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_GetChannelCommand = 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, {
-        channel: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetPlaybackKeyPairCommand = 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, {
-        keyPair: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetPlaybackRestrictionPolicyCommand = 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, {
-        playbackRestrictionPolicy: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetRecordingConfigurationCommand = 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, {
-        recordingConfiguration: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetStreamCommand = 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, {
-        stream: (_) => de__Stream(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetStreamKeyCommand = 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, {
-        streamKey: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetStreamSessionCommand = 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, {
-        streamSession: (_) => de_StreamSession(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ImportPlaybackKeyPairCommand = 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, {
-        keyPair: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListChannelsCommand = 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, {
-        channels: smithyClient._json,
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListPlaybackKeyPairsCommand = 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, {
-        keyPairs: smithyClient._json,
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListPlaybackRestrictionPoliciesCommand = 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, {
-        nextToken: smithyClient.expectString,
-        playbackRestrictionPolicies: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListRecordingConfigurationsCommand = 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, {
-        nextToken: smithyClient.expectString,
-        recordingConfigurations: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListStreamKeysCommand = 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, {
-        nextToken: smithyClient.expectString,
-        streamKeys: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListStreamsCommand = 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, {
-        nextToken: smithyClient.expectString,
-        streams: (_) => de_StreamList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListStreamSessionsCommand = 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, {
-        nextToken: smithyClient.expectString,
-        streamSessions: (_) => de_StreamSessionList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListTagsForResourceCommand = 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, {
-        tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_PutMetadataCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
 };
-const de_StartViewerSessionRevocationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_StopStreamCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UpdateChannelCommand = 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, {
-        channel: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdatePlaybackRestrictionPolicyCommand = 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, {
-        playbackRestrictionPolicy: smithyClient._json,
-    });
-    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 "AccessDeniedException":
-        case "com.amazonaws.ivs#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "PendingVerification":
-        case "com.amazonaws.ivs#PendingVerification":
-            throw await de_PendingVerificationRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.ivs#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.ivs#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.ivs#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.ivs#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.ivs#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.ivs#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "ChannelNotBroadcasting":
-        case "com.amazonaws.ivs#ChannelNotBroadcasting":
-            throw await de_ChannelNotBroadcastingRes(parsedOutput);
-        case "StreamUnavailable":
-        case "com.amazonaws.ivs#StreamUnavailable":
-            throw await de_StreamUnavailableRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(IvsServiceException);
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        exceptionMessage: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ChannelNotBroadcastingRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        exceptionMessage: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ChannelNotBroadcasting({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        exceptionMessage: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        exceptionMessage: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_PendingVerificationRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        exceptionMessage: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new PendingVerification({
-        $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, {
-        exceptionMessage: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        exceptionMessage: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ServiceQuotaExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_StreamUnavailableRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        exceptionMessage: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new StreamUnavailable({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        exceptionMessage: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        exceptionMessage: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de__Stream = (output, context) => {
-    return smithyClient.take(output, {
-        channelArn: smithyClient.expectString,
-        health: smithyClient.expectString,
-        playbackUrl: smithyClient.expectString,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        state: smithyClient.expectString,
-        streamId: smithyClient.expectString,
-        viewerCount: smithyClient.expectLong,
-    });
-};
-const de_StreamEvent = (output, context) => {
-    return smithyClient.take(output, {
-        code: smithyClient.expectString,
-        eventTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        name: smithyClient.expectString,
-        type: smithyClient.expectString,
-    });
-};
-const de_StreamEvents = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_StreamEvent(entry);
-    });
-    return retVal;
-};
-const de_StreamList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_StreamSummary(entry);
-    });
-    return retVal;
-};
-const de_StreamSession = (output, context) => {
-    return smithyClient.take(output, {
-        channel: smithyClient._json,
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        ingestConfiguration: smithyClient._json,
-        ingestConfigurations: smithyClient._json,
-        recordingConfiguration: smithyClient._json,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        streamId: smithyClient.expectString,
-        truncatedEvents: (_) => de_StreamEvents(_),
-    });
-};
-const de_StreamSessionList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_StreamSessionSummary(entry);
-    });
-    return retVal;
-};
-const de_StreamSessionSummary = (output, context) => {
-    return smithyClient.take(output, {
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        hasErrorEvent: smithyClient.expectBoolean,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        streamId: smithyClient.expectString,
-    });
-};
-const de_StreamSummary = (output, context) => {
-    return smithyClient.take(output, {
-        channelArn: smithyClient.expectString,
-        health: smithyClient.expectString,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        state: smithyClient.expectString,
-        streamId: smithyClient.expectString,
-        viewerCount: smithyClient.expectLong,
-    });
-};
-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 _AC = "AudioConfiguration";
+const _ACL = "AudioConfigurationList";
+const _ADE = "AccessDeniedException";
+const _BE = "BatchError";
+const _BEa = "BatchErrors";
+const _BGC = "BatchGetChannel";
+const _BGCR = "BatchGetChannelRequest";
+const _BGCRa = "BatchGetChannelResponse";
+const _BGSK = "BatchGetStreamKey";
+const _BGSKR = "BatchGetStreamKeyRequest";
+const _BGSKRa = "BatchGetStreamKeyResponse";
+const _BSVSR = "BatchStartViewerSessionRevocation";
+const _BSVSRE = "BatchStartViewerSessionRevocationError";
+const _BSVSREa = "BatchStartViewerSessionRevocationErrors";
+const _BSVSRR = "BatchStartViewerSessionRevocationRequest";
+const _BSVSRRa = "BatchStartViewerSessionRevocationResponse";
+const _BSVSRVS = "BatchStartViewerSessionRevocationViewerSession";
+const _BSVSRVSL = "BatchStartViewerSessionRevocationViewerSessionList";
+const _C = "Channel";
+const _CC = "CreateChannel";
+const _CCR = "CreateChannelRequest";
+const _CCRr = "CreateChannelResponse";
+const _CE = "ConflictException";
+const _CL = "ChannelList";
+const _CNB = "ChannelNotBroadcasting";
+const _CPRP = "CreatePlaybackRestrictionPolicy";
+const _CPRPR = "CreatePlaybackRestrictionPolicyRequest";
+const _CPRPRr = "CreatePlaybackRestrictionPolicyResponse";
+const _CRC = "CreateRecordingConfiguration";
+const _CRCR = "CreateRecordingConfigurationRequest";
+const _CRCRr = "CreateRecordingConfigurationResponse";
+const _CS = "ChannelSummary";
+const _CSK = "CreateStreamKey";
+const _CSKR = "CreateStreamKeyRequest";
+const _CSKRr = "CreateStreamKeyResponse";
+const _Ch = "Channels";
+const _DC = "DestinationConfiguration";
+const _DCR = "DeleteChannelRequest";
+const _DCe = "DeleteChannel";
+const _DPKP = "DeletePlaybackKeyPair";
+const _DPKPR = "DeletePlaybackKeyPairRequest";
+const _DPKPRe = "DeletePlaybackKeyPairResponse";
+const _DPRP = "DeletePlaybackRestrictionPolicy";
+const _DPRPR = "DeletePlaybackRestrictionPolicyRequest";
+const _DRC = "DeleteRecordingConfiguration";
+const _DRCR = "DeleteRecordingConfigurationRequest";
+const _DSK = "DeleteStreamKey";
+const _DSKR = "DeleteStreamKeyRequest";
+const _GC = "GetChannel";
+const _GCR = "GetChannelRequest";
+const _GCRe = "GetChannelResponse";
+const _GPKP = "GetPlaybackKeyPair";
+const _GPKPR = "GetPlaybackKeyPairRequest";
+const _GPKPRe = "GetPlaybackKeyPairResponse";
+const _GPRP = "GetPlaybackRestrictionPolicy";
+const _GPRPR = "GetPlaybackRestrictionPolicyRequest";
+const _GPRPRe = "GetPlaybackRestrictionPolicyResponse";
+const _GRC = "GetRecordingConfiguration";
+const _GRCR = "GetRecordingConfigurationRequest";
+const _GRCRe = "GetRecordingConfigurationResponse";
+const _GS = "GetStream";
+const _GSK = "GetStreamKey";
+const _GSKR = "GetStreamKeyRequest";
+const _GSKRe = "GetStreamKeyResponse";
+const _GSR = "GetStreamRequest";
+const _GSRe = "GetStreamResponse";
+const _GSS = "GetStreamSession";
+const _GSSR = "GetStreamSessionRequest";
+const _GSSRe = "GetStreamSessionResponse";
+const _IC = "IngestConfiguration";
+const _ICn = "IngestConfigurations";
+const _IPKP = "ImportPlaybackKeyPair";
+const _IPKPR = "ImportPlaybackKeyPairRequest";
+const _IPKPRm = "ImportPlaybackKeyPairResponse";
+const _ISE = "InternalServerException";
+const _LC = "ListChannels";
+const _LCR = "ListChannelsRequest";
+const _LCRi = "ListChannelsResponse";
+const _LPKP = "ListPlaybackKeyPairs";
+const _LPKPR = "ListPlaybackKeyPairsRequest";
+const _LPKPRi = "ListPlaybackKeyPairsResponse";
+const _LPRP = "ListPlaybackRestrictionPolicies";
+const _LPRPR = "ListPlaybackRestrictionPoliciesRequest";
+const _LPRPRi = "ListPlaybackRestrictionPoliciesResponse";
+const _LRC = "ListRecordingConfigurations";
+const _LRCR = "ListRecordingConfigurationsRequest";
+const _LRCRi = "ListRecordingConfigurationsResponse";
+const _LS = "ListStreams";
+const _LSK = "ListStreamKeys";
+const _LSKR = "ListStreamKeysRequest";
+const _LSKRi = "ListStreamKeysResponse";
+const _LSR = "ListStreamsRequest";
+const _LSRi = "ListStreamsResponse";
+const _LSS = "ListStreamSessions";
+const _LSSR = "ListStreamSessionsRequest";
+const _LSSRi = "ListStreamSessionsResponse";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _MIC = "MultitrackInputConfiguration";
+const _PKP = "PlaybackKeyPair";
+const _PKPL = "PlaybackKeyPairList";
+const _PKPS = "PlaybackKeyPairSummary";
+const _PM = "PutMetadata";
+const _PMR = "PutMetadataRequest";
+const _PRP = "PlaybackRestrictionPolicy";
+const _PRPL = "PlaybackRestrictionPolicyList";
+const _PRPS = "PlaybackRestrictionPolicySummary";
+const _PV = "PendingVerification";
+const _RC = "RecordingConfiguration";
+const _RCL = "RecordingConfigurationList";
+const _RCS = "RecordingConfigurationSummary";
+const _RCe = "RenditionConfiguration";
+const _RNFE = "ResourceNotFoundException";
+const _S = "Srt";
+const _SDC = "S3DestinationConfiguration";
+const _SE = "StreamEvent";
+const _SEt = "StreamEvents";
+const _SF = "StreamFilters";
+const _SK = "StreamKey";
+const _SKL = "StreamKeyList";
+const _SKS = "StreamKeySummary";
+const _SKV = "StreamKeyValue";
+const _SKt = "StreamKeys";
+const _SL = "StreamList";
+const _SM = "StreamMetadata";
+const _SP = "SrtPassphrase";
+const _SQEE = "ServiceQuotaExceededException";
+const _SS = "StreamSession";
+const _SSL = "StreamSessionList";
+const _SSR = "StopStreamRequest";
+const _SSRt = "StopStreamResponse";
+const _SSS = "StreamSessionSummary";
+const _SSt = "StreamSummary";
+const _SSto = "StopStream";
+const _SU = "StreamUnavailable";
+const _SVSR = "StartViewerSessionRevocation";
+const _SVSRR = "StartViewerSessionRevocationRequest";
+const _SVSRRt = "StartViewerSessionRevocationResponse";
+const _St = "Stream";
+const _TC = "ThumbnailConfiguration";
+const _TE = "ThrottlingException";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _UC = "UpdateChannel";
+const _UCR = "UpdateChannelRequest";
+const _UCRp = "UpdateChannelResponse";
+const _UPRP = "UpdatePlaybackRestrictionPolicy";
+const _UPRPR = "UpdatePlaybackRestrictionPolicyRequest";
+const _UPRPRp = "UpdatePlaybackRestrictionPolicyResponse";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _VC = "VideoConfiguration";
+const _VCL = "VideoConfigurationList";
+const _VE = "ValidationException";
+const _a = "arn";
+const _aC = "allowedCountries";
+const _aCu = "audioConfigurations";
+const _aL = "avcLevel";
+const _aO = "allowedOrigins";
+const _aP = "avcProfile";
+const _ar = "arns";
+const _au = "authorized";
+const _aud = "audio";
+const _bN = "bucketName";
+const _c = "client";
+const _cA = "channelArn";
+const _cF = "containerFormat";
+const _ch = "channels";
+const _cha = "channel";
+const _co = "codec";
+const _cod = "code";
+const _dC = "destinationConfiguration";
+const _e = "error";
+const _eM = "exceptionMessage";
+const _eSOE = "enableStrictOriginEnforcement";
+const _eT = "eventTime";
+const _eTn = "endTime";
+const _en = "enabled";
+const _enc = "encoder";
+const _end = "endpoint";
+const _er = "errors";
+const _f = "fingerprint";
+const _fB = "filterBy";
+const _fBN = "filterByName";
+const _fBPRPA = "filterByPlaybackRestrictionPolicyArn";
+const _fBRCA = "filterByRecordingConfigurationArn";
+const _h = "health";
+const _hE = "httpError";
+const _hEE = "hasErrorEvent";
+const _hQ = "httpQuery";
+const _ht = "http";
+const _iC = "ingestConfiguration";
+const _iCn = "ingestConfigurations";
+const _iE = "ingestEndpoint";
+const _iI = "insecureIngest";
+const _kP = "keyPair";
+const _kPe = "keyPairs";
+const _l = "level";
+const _lM = "latencyMode";
+const _m = "message";
+const _mIC = "multitrackInputConfiguration";
+const _mR = "maxResults";
+const _mRa = "maximumResolution";
+const _me = "metadata";
+const _n = "name";
+const _nT = "nextToken";
+const _p = "preset";
+const _pKM = "publicKeyMaterial";
+const _pRP = "playbackRestrictionPolicy";
+const _pRPA = "playbackRestrictionPolicyArn";
+const _pRPl = "playbackRestrictionPolicies";
+const _pU = "playbackUrl";
+const _pa = "passphrase";
+const _po = "policy";
+const _pr = "profile";
+const _r = "renditions";
+const _rA = "resourceArn";
+const _rC = "renditionConfiguration";
+const _rCA = "recordingConfigurationArn";
+const _rCe = "recordingConfiguration";
+const _rCec = "recordingConfigurations";
+const _rM = "recordingMode";
+const _rRWS = "recordingReconnectWindowSeconds";
+const _rS = "renditionSelection";
+const _re = "resolution";
+const _s = "srt";
+const _sI = "streamId";
+const _sK = "streamKeys";
+const _sKt = "streamKey";
+const _sR = "sampleRate";
+const _sS = "streamSession";
+const _sSt = "streamSessions";
+const _sT = "startTime";
+const _s_ = "s3";
+const _se = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.ivs";
+const _st = "stream";
+const _sta = "state";
+const _sto = "storage";
+const _str = "streams";
+const _t = "track";
+const _tB = "targetBitrate";
+const _tC = "thumbnailConfiguration";
+const _tE = "truncatedEvents";
+const _tF = "targetFramerate";
+const _tIS = "targetIntervalSeconds";
 const _tK = "tagKeys";
+const _ta = "tags";
+const _ty = "type";
+const _v = "video";
+const _vC = "videoConfigurations";
+const _vCi = "viewerCount";
+const _vH = "videoHeight";
+const _vI = "viewerId";
+const _vS = "viewerSessions";
+const _vSVLTOET = "viewerSessionVersionsLessThanOrEqualTo";
+const _vW = "videoWidth";
+const _va = "value";
+const n0 = "com.amazonaws.ivs";
+var SrtPassphrase = [0, n0, _SP, 8, 0];
+var StreamKeyValue = [0, n0, _SKV, 8, 0];
+var StreamMetadata = [0, n0, _SM, 8, 0];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_eM],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var AudioConfiguration = [3, n0, _AC, 0, [_co, _tB, _sR, _ch, _t], [0, 1, 1, 1, 0]];
+var BatchError = [3, n0, _BE, 0, [_a, _cod, _m], [0, 0, 0]];
+var BatchGetChannelRequest = [3, n0, _BGCR, 0, [_ar], [64 | 0]];
+var BatchGetChannelResponse = [
+    3,
+    n0,
+    _BGCRa,
+    0,
+    [_ch, _er],
+    [[() => Channels, 0], () => BatchErrors],
+];
+var BatchGetStreamKeyRequest = [3, n0, _BGSKR, 0, [_ar], [64 | 0]];
+var BatchGetStreamKeyResponse = [
+    3,
+    n0,
+    _BGSKRa,
+    0,
+    [_sK, _er],
+    [[() => StreamKeys, 0], () => BatchErrors],
+];
+var BatchStartViewerSessionRevocationError = [
+    3,
+    n0,
+    _BSVSRE,
+    0,
+    [_cA, _vI, _cod, _m],
+    [0, 0, 0, 0],
+];
+var BatchStartViewerSessionRevocationRequest = [
+    3,
+    n0,
+    _BSVSRR,
+    0,
+    [_vS],
+    [() => BatchStartViewerSessionRevocationViewerSessionList],
+];
+var BatchStartViewerSessionRevocationResponse = [
+    3,
+    n0,
+    _BSVSRRa,
+    0,
+    [_er],
+    [() => BatchStartViewerSessionRevocationErrors],
+];
+var BatchStartViewerSessionRevocationViewerSession = [
+    3,
+    n0,
+    _BSVSRVS,
+    0,
+    [_cA, _vI, _vSVLTOET],
+    [0, 0, 1],
+];
+var Channel = [
+    3,
+    n0,
+    _C,
+    0,
+    [_a, _n, _lM, _ty, _rCA, _iE, _pU, _au, _ta, _iI, _p, _s, _pRPA, _mIC, _cF],
+    [0, 0, 0, 0, 0, 0, 0, 2, 128 | 0, 2, 0, [() => Srt, 0], 0, () => MultitrackInputConfiguration, 0],
+];
+var ChannelNotBroadcasting = [
+    -3,
+    n0,
+    _CNB,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_eM],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ChannelNotBroadcasting, ChannelNotBroadcasting$1);
+var ChannelSummary = [
+    3,
+    n0,
+    _CS,
+    0,
+    [_a, _n, _lM, _au, _rCA, _ta, _iI, _ty, _p, _pRPA],
+    [0, 0, 0, 2, 0, 128 | 0, 2, 0, 0, 0],
+];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_eM],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CreateChannelRequest = [
+    3,
+    n0,
+    _CCR,
+    0,
+    [_n, _lM, _ty, _au, _rCA, _ta, _iI, _p, _pRPA, _mIC, _cF],
+    [0, 0, 0, 2, 0, 128 | 0, 2, 0, 0, () => MultitrackInputConfiguration, 0],
+];
+var CreateChannelResponse = [
+    3,
+    n0,
+    _CCRr,
+    0,
+    [_cha, _sKt],
+    [
+        [() => Channel, 0],
+        [() => StreamKey, 0],
+    ],
+];
+var CreatePlaybackRestrictionPolicyRequest = [
+    3,
+    n0,
+    _CPRPR,
+    0,
+    [_aC, _aO, _eSOE, _n, _ta],
+    [64 | 0, 64 | 0, 2, 0, 128 | 0],
+];
+var CreatePlaybackRestrictionPolicyResponse = [
+    3,
+    n0,
+    _CPRPRr,
+    0,
+    [_pRP],
+    [() => PlaybackRestrictionPolicy],
+];
+var CreateRecordingConfigurationRequest = [
+    3,
+    n0,
+    _CRCR,
+    0,
+    [_n, _dC, _ta, _tC, _rRWS, _rC],
+    [0, () => DestinationConfiguration, 128 | 0, () => ThumbnailConfiguration, 1, () => RenditionConfiguration],
+];
+var CreateRecordingConfigurationResponse = [
+    3,
+    n0,
+    _CRCRr,
+    0,
+    [_rCe],
+    [() => RecordingConfiguration],
+];
+var CreateStreamKeyRequest = [3, n0, _CSKR, 0, [_cA, _ta], [0, 128 | 0]];
+var CreateStreamKeyResponse = [3, n0, _CSKRr, 0, [_sKt], [[() => StreamKey, 0]]];
+var DeleteChannelRequest = [3, n0, _DCR, 0, [_a], [0]];
+var DeletePlaybackKeyPairRequest = [3, n0, _DPKPR, 0, [_a], [0]];
+var DeletePlaybackKeyPairResponse = [3, n0, _DPKPRe, 0, [], []];
+var DeletePlaybackRestrictionPolicyRequest = [3, n0, _DPRPR, 0, [_a], [0]];
+var DeleteRecordingConfigurationRequest = [3, n0, _DRCR, 0, [_a], [0]];
+var DeleteStreamKeyRequest = [3, n0, _DSKR, 0, [_a], [0]];
+var DestinationConfiguration = [3, n0, _DC, 0, [_s_], [() => S3DestinationConfiguration]];
+var GetChannelRequest = [3, n0, _GCR, 0, [_a], [0]];
+var GetChannelResponse = [3, n0, _GCRe, 0, [_cha], [[() => Channel, 0]]];
+var GetPlaybackKeyPairRequest = [3, n0, _GPKPR, 0, [_a], [0]];
+var GetPlaybackKeyPairResponse = [3, n0, _GPKPRe, 0, [_kP], [() => PlaybackKeyPair]];
+var GetPlaybackRestrictionPolicyRequest = [3, n0, _GPRPR, 0, [_a], [0]];
+var GetPlaybackRestrictionPolicyResponse = [
+    3,
+    n0,
+    _GPRPRe,
+    0,
+    [_pRP],
+    [() => PlaybackRestrictionPolicy],
+];
+var GetRecordingConfigurationRequest = [3, n0, _GRCR, 0, [_a], [0]];
+var GetRecordingConfigurationResponse = [
+    3,
+    n0,
+    _GRCRe,
+    0,
+    [_rCe],
+    [() => RecordingConfiguration],
+];
+var GetStreamKeyRequest = [3, n0, _GSKR, 0, [_a], [0]];
+var GetStreamKeyResponse = [3, n0, _GSKRe, 0, [_sKt], [[() => StreamKey, 0]]];
+var GetStreamRequest = [3, n0, _GSR, 0, [_cA], [0]];
+var GetStreamResponse = [3, n0, _GSRe, 0, [_st], [() => _Stream]];
+var GetStreamSessionRequest = [3, n0, _GSSR, 0, [_cA, _sI], [0, 0]];
+var GetStreamSessionResponse = [3, n0, _GSSRe, 0, [_sS], [[() => StreamSession, 0]]];
+var ImportPlaybackKeyPairRequest = [3, n0, _IPKPR, 0, [_pKM, _n, _ta], [0, 0, 128 | 0]];
+var ImportPlaybackKeyPairResponse = [3, n0, _IPKPRm, 0, [_kP], [() => PlaybackKeyPair]];
+var IngestConfiguration = [
+    3,
+    n0,
+    _IC,
+    0,
+    [_v, _aud],
+    [() => VideoConfiguration, () => AudioConfiguration],
+];
+var IngestConfigurations = [
+    3,
+    n0,
+    _ICn,
+    0,
+    [_vC, _aCu],
+    [() => VideoConfigurationList, () => AudioConfigurationList],
+];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _se,
+        [_hE]: 500,
+    },
+    [_eM],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var ListChannelsRequest = [
+    3,
+    n0,
+    _LCR,
+    0,
+    [_fBN, _fBRCA, _fBPRPA, _nT, _mR],
+    [0, 0, 0, 0, 1],
+];
+var ListChannelsResponse = [3, n0, _LCRi, 0, [_ch, _nT], [() => ChannelList, 0]];
+var ListPlaybackKeyPairsRequest = [3, n0, _LPKPR, 0, [_nT, _mR], [0, 1]];
+var ListPlaybackKeyPairsResponse = [
+    3,
+    n0,
+    _LPKPRi,
+    0,
+    [_kPe, _nT],
+    [() => PlaybackKeyPairList, 0],
+];
+var ListPlaybackRestrictionPoliciesRequest = [3, n0, _LPRPR, 0, [_nT, _mR], [0, 1]];
+var ListPlaybackRestrictionPoliciesResponse = [
+    3,
+    n0,
+    _LPRPRi,
+    0,
+    [_pRPl, _nT],
+    [() => PlaybackRestrictionPolicyList, 0],
+];
+var ListRecordingConfigurationsRequest = [3, n0, _LRCR, 0, [_nT, _mR], [0, 1]];
+var ListRecordingConfigurationsResponse = [
+    3,
+    n0,
+    _LRCRi,
+    0,
+    [_rCec, _nT],
+    [() => RecordingConfigurationList, 0],
+];
+var ListStreamKeysRequest = [3, n0, _LSKR, 0, [_cA, _nT, _mR], [0, 0, 1]];
+var ListStreamKeysResponse = [3, n0, _LSKRi, 0, [_sK, _nT], [() => StreamKeyList, 0]];
+var ListStreamSessionsRequest = [3, n0, _LSSR, 0, [_cA, _nT, _mR], [0, 0, 1]];
+var ListStreamSessionsResponse = [
+    3,
+    n0,
+    _LSSRi,
+    0,
+    [_sSt, _nT],
+    [() => StreamSessionList, 0],
+];
+var ListStreamsRequest = [3, n0, _LSR, 0, [_fB, _nT, _mR], [() => StreamFilters, 0, 1]];
+var ListStreamsResponse = [3, n0, _LSRi, 0, [_str, _nT], [() => StreamList, 0]];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_rA], [[0, 1]]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_ta], [128 | 0]];
+var MultitrackInputConfiguration = [3, n0, _MIC, 0, [_en, _po, _mRa], [2, 0, 0]];
+var PendingVerification = [
+    -3,
+    n0,
+    _PV,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_eM],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(PendingVerification, PendingVerification$1);
+var PlaybackKeyPair = [3, n0, _PKP, 0, [_a, _n, _f, _ta], [0, 0, 0, 128 | 0]];
+var PlaybackKeyPairSummary = [3, n0, _PKPS, 0, [_a, _n, _ta], [0, 0, 128 | 0]];
+var PlaybackRestrictionPolicy = [
+    3,
+    n0,
+    _PRP,
+    0,
+    [_a, _aC, _aO, _eSOE, _n, _ta],
+    [0, 64 | 0, 64 | 0, 2, 0, 128 | 0],
+];
+var PlaybackRestrictionPolicySummary = [
+    3,
+    n0,
+    _PRPS,
+    0,
+    [_a, _aC, _aO, _eSOE, _n, _ta],
+    [0, 64 | 0, 64 | 0, 2, 0, 128 | 0],
+];
+var PutMetadataRequest = [3, n0, _PMR, 0, [_cA, _me], [0, [() => StreamMetadata, 0]]];
+var RecordingConfiguration = [
+    3,
+    n0,
+    _RC,
+    0,
+    [_a, _n, _dC, _sta, _ta, _tC, _rRWS, _rC],
+    [0, 0, () => DestinationConfiguration, 0, 128 | 0, () => ThumbnailConfiguration, 1, () => RenditionConfiguration],
+];
+var RecordingConfigurationSummary = [
+    3,
+    n0,
+    _RCS,
+    0,
+    [_a, _n, _dC, _sta, _ta],
+    [0, 0, () => DestinationConfiguration, 0, 128 | 0],
+];
+var RenditionConfiguration = [3, n0, _RCe, 0, [_rS, _r], [0, 64 | 0]];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_eM],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var S3DestinationConfiguration = [3, n0, _SDC, 0, [_bN], [0]];
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_eM],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var Srt = [3, n0, _S, 0, [_end, _pa], [0, [() => SrtPassphrase, 0]]];
+var StartViewerSessionRevocationRequest = [
+    3,
+    n0,
+    _SVSRR,
+    0,
+    [_cA, _vI, _vSVLTOET],
+    [0, 0, 1],
+];
+var StartViewerSessionRevocationResponse = [3, n0, _SVSRRt, 0, [], []];
+var StopStreamRequest = [3, n0, _SSR, 0, [_cA], [0]];
+var StopStreamResponse = [3, n0, _SSRt, 0, [], []];
+var _Stream = [
+    3,
+    n0,
+    _St,
+    0,
+    [_cA, _sI, _pU, _sT, _sta, _h, _vCi],
+    [0, 0, 0, 5, 0, 0, 1],
+];
+var StreamEvent = [3, n0, _SE, 0, [_n, _ty, _eT, _cod], [0, 0, 5, 0]];
+var StreamFilters = [3, n0, _SF, 0, [_h], [0]];
+var StreamKey = [
+    3,
+    n0,
+    _SK,
+    0,
+    [_a, _va, _cA, _ta],
+    [0, [() => StreamKeyValue, 0], 0, 128 | 0],
+];
+var StreamKeySummary = [3, n0, _SKS, 0, [_a, _cA, _ta], [0, 0, 128 | 0]];
+var StreamSession = [
+    3,
+    n0,
+    _SS,
+    0,
+    [_sI, _sT, _eTn, _cha, _iC, _iCn, _rCe, _tE],
+    [
+        0,
+        5,
+        5,
+        [() => Channel, 0],
+        () => IngestConfiguration,
+        () => IngestConfigurations,
+        () => RecordingConfiguration,
+        () => StreamEvents,
+    ],
+];
+var StreamSessionSummary = [3, n0, _SSS, 0, [_sI, _sT, _eTn, _hEE], [0, 5, 5, 2]];
+var StreamSummary = [3, n0, _SSt, 0, [_cA, _sI, _sta, _h, _vCi, _sT], [0, 0, 0, 0, 1, 5]];
+var StreamUnavailable = [
+    -3,
+    n0,
+    _SU,
+    {
+        [_e]: _se,
+        [_hE]: 503,
+    },
+    [_eM],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(StreamUnavailable, StreamUnavailable$1);
+var TagResourceRequest = [3, n0, _TRR, 0, [_rA, _ta], [[0, 1], 128 | 0]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_eM],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var ThumbnailConfiguration = [3, n0, _TC, 0, [_rM, _tIS, _re, _sto], [0, 1, 0, 64 | 0]];
+var UntagResourceRequest = [
+    3,
+    n0,
+    _URR,
+    0,
+    [_rA, _tK],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UpdateChannelRequest = [
+    3,
+    n0,
+    _UCR,
+    0,
+    [_a, _n, _lM, _ty, _au, _rCA, _iI, _p, _pRPA, _mIC, _cF],
+    [0, 0, 0, 0, 2, 0, 2, 0, 0, () => MultitrackInputConfiguration, 0],
+];
+var UpdateChannelResponse = [3, n0, _UCRp, 0, [_cha], [[() => Channel, 0]]];
+var UpdatePlaybackRestrictionPolicyRequest = [
+    3,
+    n0,
+    _UPRPR,
+    0,
+    [_a, _aC, _aO, _eSOE, _n],
+    [0, 64 | 0, 64 | 0, 2, 0],
+];
+var UpdatePlaybackRestrictionPolicyResponse = [
+    3,
+    n0,
+    _UPRPRp,
+    0,
+    [_pRP],
+    [() => PlaybackRestrictionPolicy],
+];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_eM],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var VideoConfiguration = [
+    3,
+    n0,
+    _VC,
+    0,
+    [_aP, _aL, _co, _enc, _tB, _tF, _vH, _vW, _l, _t, _pr],
+    [0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0],
+];
+var __Unit = "unit";
+var IvsServiceException = [-3, _sm, "IvsServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(IvsServiceException, IvsServiceException$1);
+var AudioConfigurationList = [1, n0, _ACL, 0, () => AudioConfiguration];
+var BatchErrors = [1, n0, _BEa, 0, () => BatchError];
+var BatchStartViewerSessionRevocationErrors = [
+    1,
+    n0,
+    _BSVSREa,
+    0,
+    () => BatchStartViewerSessionRevocationError,
+];
+var BatchStartViewerSessionRevocationViewerSessionList = [
+    1,
+    n0,
+    _BSVSRVSL,
+    0,
+    () => BatchStartViewerSessionRevocationViewerSession,
+];
+var ChannelList = [1, n0, _CL, 0, () => ChannelSummary];
+var Channels = [1, n0, _Ch, 0, [() => Channel, 0]];
+var PlaybackKeyPairList = [1, n0, _PKPL, 0, () => PlaybackKeyPairSummary];
+var PlaybackRestrictionPolicyList = [1, n0, _PRPL, 0, () => PlaybackRestrictionPolicySummary];
+var RecordingConfigurationList = [1, n0, _RCL, 0, () => RecordingConfigurationSummary];
+var StreamEvents = [1, n0, _SEt, 0, () => StreamEvent];
+var StreamKeyList = [1, n0, _SKL, 0, () => StreamKeySummary];
+var StreamKeys = [1, n0, _SKt, 0, [() => StreamKey, 0]];
+var StreamList = [1, n0, _SL, 0, () => StreamSummary];
+var StreamSessionList = [1, n0, _SSL, 0, () => StreamSessionSummary];
+var VideoConfigurationList = [1, n0, _VCL, 0, () => VideoConfiguration];
+var BatchGetChannel = [
+    9,
+    n0,
+    _BGC,
+    {
+        [_ht]: ["POST", "/BatchGetChannel", 200],
+    },
+    () => BatchGetChannelRequest,
+    () => BatchGetChannelResponse,
+];
+var BatchGetStreamKey = [
+    9,
+    n0,
+    _BGSK,
+    {
+        [_ht]: ["POST", "/BatchGetStreamKey", 200],
+    },
+    () => BatchGetStreamKeyRequest,
+    () => BatchGetStreamKeyResponse,
+];
+var BatchStartViewerSessionRevocation = [
+    9,
+    n0,
+    _BSVSR,
+    {
+        [_ht]: ["POST", "/BatchStartViewerSessionRevocation", 200],
+    },
+    () => BatchStartViewerSessionRevocationRequest,
+    () => BatchStartViewerSessionRevocationResponse,
+];
+var CreateChannel = [
+    9,
+    n0,
+    _CC,
+    {
+        [_ht]: ["POST", "/CreateChannel", 200],
+    },
+    () => CreateChannelRequest,
+    () => CreateChannelResponse,
+];
+var CreatePlaybackRestrictionPolicy = [
+    9,
+    n0,
+    _CPRP,
+    {
+        [_ht]: ["POST", "/CreatePlaybackRestrictionPolicy", 200],
+    },
+    () => CreatePlaybackRestrictionPolicyRequest,
+    () => CreatePlaybackRestrictionPolicyResponse,
+];
+var CreateRecordingConfiguration = [
+    9,
+    n0,
+    _CRC,
+    {
+        [_ht]: ["POST", "/CreateRecordingConfiguration", 200],
+    },
+    () => CreateRecordingConfigurationRequest,
+    () => CreateRecordingConfigurationResponse,
+];
+var CreateStreamKey = [
+    9,
+    n0,
+    _CSK,
+    {
+        [_ht]: ["POST", "/CreateStreamKey", 200],
+    },
+    () => CreateStreamKeyRequest,
+    () => CreateStreamKeyResponse,
+];
+var DeleteChannel = [
+    9,
+    n0,
+    _DCe,
+    {
+        [_ht]: ["POST", "/DeleteChannel", 204],
+    },
+    () => DeleteChannelRequest,
+    () => __Unit,
+];
+var DeletePlaybackKeyPair = [
+    9,
+    n0,
+    _DPKP,
+    {
+        [_ht]: ["POST", "/DeletePlaybackKeyPair", 200],
+    },
+    () => DeletePlaybackKeyPairRequest,
+    () => DeletePlaybackKeyPairResponse,
+];
+var DeletePlaybackRestrictionPolicy = [
+    9,
+    n0,
+    _DPRP,
+    {
+        [_ht]: ["POST", "/DeletePlaybackRestrictionPolicy", 204],
+    },
+    () => DeletePlaybackRestrictionPolicyRequest,
+    () => __Unit,
+];
+var DeleteRecordingConfiguration = [
+    9,
+    n0,
+    _DRC,
+    {
+        [_ht]: ["POST", "/DeleteRecordingConfiguration", 204],
+    },
+    () => DeleteRecordingConfigurationRequest,
+    () => __Unit,
+];
+var DeleteStreamKey = [
+    9,
+    n0,
+    _DSK,
+    {
+        [_ht]: ["POST", "/DeleteStreamKey", 204],
+    },
+    () => DeleteStreamKeyRequest,
+    () => __Unit,
+];
+var GetChannel = [
+    9,
+    n0,
+    _GC,
+    {
+        [_ht]: ["POST", "/GetChannel", 200],
+    },
+    () => GetChannelRequest,
+    () => GetChannelResponse,
+];
+var GetPlaybackKeyPair = [
+    9,
+    n0,
+    _GPKP,
+    {
+        [_ht]: ["POST", "/GetPlaybackKeyPair", 200],
+    },
+    () => GetPlaybackKeyPairRequest,
+    () => GetPlaybackKeyPairResponse,
+];
+var GetPlaybackRestrictionPolicy = [
+    9,
+    n0,
+    _GPRP,
+    {
+        [_ht]: ["POST", "/GetPlaybackRestrictionPolicy", 200],
+    },
+    () => GetPlaybackRestrictionPolicyRequest,
+    () => GetPlaybackRestrictionPolicyResponse,
+];
+var GetRecordingConfiguration = [
+    9,
+    n0,
+    _GRC,
+    {
+        [_ht]: ["POST", "/GetRecordingConfiguration", 200],
+    },
+    () => GetRecordingConfigurationRequest,
+    () => GetRecordingConfigurationResponse,
+];
+var GetStream = [
+    9,
+    n0,
+    _GS,
+    {
+        [_ht]: ["POST", "/GetStream", 200],
+    },
+    () => GetStreamRequest,
+    () => GetStreamResponse,
+];
+var GetStreamKey = [
+    9,
+    n0,
+    _GSK,
+    {
+        [_ht]: ["POST", "/GetStreamKey", 200],
+    },
+    () => GetStreamKeyRequest,
+    () => GetStreamKeyResponse,
+];
+var GetStreamSession = [
+    9,
+    n0,
+    _GSS,
+    {
+        [_ht]: ["POST", "/GetStreamSession", 200],
+    },
+    () => GetStreamSessionRequest,
+    () => GetStreamSessionResponse,
+];
+var ImportPlaybackKeyPair = [
+    9,
+    n0,
+    _IPKP,
+    {
+        [_ht]: ["POST", "/ImportPlaybackKeyPair", 200],
+    },
+    () => ImportPlaybackKeyPairRequest,
+    () => ImportPlaybackKeyPairResponse,
+];
+var ListChannels = [
+    9,
+    n0,
+    _LC,
+    {
+        [_ht]: ["POST", "/ListChannels", 200],
+    },
+    () => ListChannelsRequest,
+    () => ListChannelsResponse,
+];
+var ListPlaybackKeyPairs = [
+    9,
+    n0,
+    _LPKP,
+    {
+        [_ht]: ["POST", "/ListPlaybackKeyPairs", 200],
+    },
+    () => ListPlaybackKeyPairsRequest,
+    () => ListPlaybackKeyPairsResponse,
+];
+var ListPlaybackRestrictionPolicies = [
+    9,
+    n0,
+    _LPRP,
+    {
+        [_ht]: ["POST", "/ListPlaybackRestrictionPolicies", 200],
+    },
+    () => ListPlaybackRestrictionPoliciesRequest,
+    () => ListPlaybackRestrictionPoliciesResponse,
+];
+var ListRecordingConfigurations = [
+    9,
+    n0,
+    _LRC,
+    {
+        [_ht]: ["POST", "/ListRecordingConfigurations", 200],
+    },
+    () => ListRecordingConfigurationsRequest,
+    () => ListRecordingConfigurationsResponse,
+];
+var ListStreamKeys = [
+    9,
+    n0,
+    _LSK,
+    {
+        [_ht]: ["POST", "/ListStreamKeys", 200],
+    },
+    () => ListStreamKeysRequest,
+    () => ListStreamKeysResponse,
+];
+var ListStreams = [
+    9,
+    n0,
+    _LS,
+    {
+        [_ht]: ["POST", "/ListStreams", 200],
+    },
+    () => ListStreamsRequest,
+    () => ListStreamsResponse,
+];
+var ListStreamSessions = [
+    9,
+    n0,
+    _LSS,
+    {
+        [_ht]: ["POST", "/ListStreamSessions", 200],
+    },
+    () => ListStreamSessionsRequest,
+    () => ListStreamSessionsResponse,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_ht]: ["GET", "/tags/{resourceArn}", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var PutMetadata = [
+    9,
+    n0,
+    _PM,
+    {
+        [_ht]: ["POST", "/PutMetadata", 204],
+    },
+    () => PutMetadataRequest,
+    () => __Unit,
+];
+var StartViewerSessionRevocation = [
+    9,
+    n0,
+    _SVSR,
+    {
+        [_ht]: ["POST", "/StartViewerSessionRevocation", 200],
+    },
+    () => StartViewerSessionRevocationRequest,
+    () => StartViewerSessionRevocationResponse,
+];
+var StopStream = [
+    9,
+    n0,
+    _SSto,
+    {
+        [_ht]: ["POST", "/StopStream", 200],
+    },
+    () => StopStreamRequest,
+    () => StopStreamResponse,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_ht]: ["POST", "/tags/{resourceArn}", 200],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResponse,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_ht]: ["DELETE", "/tags/{resourceArn}", 200],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
+var UpdateChannel = [
+    9,
+    n0,
+    _UC,
+    {
+        [_ht]: ["POST", "/UpdateChannel", 200],
+    },
+    () => UpdateChannelRequest,
+    () => UpdateChannelResponse,
+];
+var UpdatePlaybackRestrictionPolicy = [
+    9,
+    n0,
+    _UPRP,
+    {
+        [_ht]: ["POST", "/UpdatePlaybackRestrictionPolicy", 200],
+    },
+    () => UpdatePlaybackRestrictionPolicyRequest,
+    () => UpdatePlaybackRestrictionPolicyResponse,
+];
 
 class BatchGetChannelCommand 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("AmazonInteractiveVideoService", "BatchGetChannel", {})
     .n("IvsClient", "BatchGetChannelCommand")
-    .f(void 0, BatchGetChannelResponseFilterSensitiveLog)
-    .ser(se_BatchGetChannelCommand)
-    .de(de_BatchGetChannelCommand)
+    .sc(BatchGetChannel)
     .build() {
 }
 
@@ -1620,16 +1472,11 @@ class BatchGetStreamKeyCommand 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("AmazonInteractiveVideoService", "BatchGetStreamKey", {})
     .n("IvsClient", "BatchGetStreamKeyCommand")
-    .f(void 0, BatchGetStreamKeyResponseFilterSensitiveLog)
-    .ser(se_BatchGetStreamKeyCommand)
-    .de(de_BatchGetStreamKeyCommand)
+    .sc(BatchGetStreamKey)
     .build() {
 }
 
@@ -1637,16 +1484,11 @@ class BatchStartViewerSessionRevocationCommand 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("AmazonInteractiveVideoService", "BatchStartViewerSessionRevocation", {})
     .n("IvsClient", "BatchStartViewerSessionRevocationCommand")
-    .f(void 0, void 0)
-    .ser(se_BatchStartViewerSessionRevocationCommand)
-    .de(de_BatchStartViewerSessionRevocationCommand)
+    .sc(BatchStartViewerSessionRevocation)
     .build() {
 }
 
@@ -1654,16 +1496,11 @@ class CreateChannelCommand 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("AmazonInteractiveVideoService", "CreateChannel", {})
     .n("IvsClient", "CreateChannelCommand")
-    .f(void 0, CreateChannelResponseFilterSensitiveLog)
-    .ser(se_CreateChannelCommand)
-    .de(de_CreateChannelCommand)
+    .sc(CreateChannel)
     .build() {
 }
 
@@ -1671,16 +1508,11 @@ class CreatePlaybackRestrictionPolicyCommand 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("AmazonInteractiveVideoService", "CreatePlaybackRestrictionPolicy", {})
     .n("IvsClient", "CreatePlaybackRestrictionPolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_CreatePlaybackRestrictionPolicyCommand)
-    .de(de_CreatePlaybackRestrictionPolicyCommand)
+    .sc(CreatePlaybackRestrictionPolicy)
     .build() {
 }
 
@@ -1688,16 +1520,11 @@ class CreateRecordingConfigurationCommand 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("AmazonInteractiveVideoService", "CreateRecordingConfiguration", {})
     .n("IvsClient", "CreateRecordingConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateRecordingConfigurationCommand)
-    .de(de_CreateRecordingConfigurationCommand)
+    .sc(CreateRecordingConfiguration)
     .build() {
 }
 
@@ -1705,16 +1532,11 @@ class CreateStreamKeyCommand 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("AmazonInteractiveVideoService", "CreateStreamKey", {})
     .n("IvsClient", "CreateStreamKeyCommand")
-    .f(void 0, CreateStreamKeyResponseFilterSensitiveLog)
-    .ser(se_CreateStreamKeyCommand)
-    .de(de_CreateStreamKeyCommand)
+    .sc(CreateStreamKey)
     .build() {
 }
 
@@ -1722,16 +1544,11 @@ class DeleteChannelCommand 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("AmazonInteractiveVideoService", "DeleteChannel", {})
     .n("IvsClient", "DeleteChannelCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteChannelCommand)
-    .de(de_DeleteChannelCommand)
+    .sc(DeleteChannel)
     .build() {
 }
 
@@ -1739,16 +1556,11 @@ class DeletePlaybackKeyPairCommand 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("AmazonInteractiveVideoService", "DeletePlaybackKeyPair", {})
     .n("IvsClient", "DeletePlaybackKeyPairCommand")
-    .f(void 0, void 0)
-    .ser(se_DeletePlaybackKeyPairCommand)
-    .de(de_DeletePlaybackKeyPairCommand)
+    .sc(DeletePlaybackKeyPair)
     .build() {
 }
 
@@ -1756,16 +1568,11 @@ class DeletePlaybackRestrictionPolicyCommand 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("AmazonInteractiveVideoService", "DeletePlaybackRestrictionPolicy", {})
     .n("IvsClient", "DeletePlaybackRestrictionPolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_DeletePlaybackRestrictionPolicyCommand)
-    .de(de_DeletePlaybackRestrictionPolicyCommand)
+    .sc(DeletePlaybackRestrictionPolicy)
     .build() {
 }
 
@@ -1773,16 +1580,11 @@ class DeleteRecordingConfigurationCommand 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("AmazonInteractiveVideoService", "DeleteRecordingConfiguration", {})
     .n("IvsClient", "DeleteRecordingConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteRecordingConfigurationCommand)
-    .de(de_DeleteRecordingConfigurationCommand)
+    .sc(DeleteRecordingConfiguration)
     .build() {
 }
 
@@ -1790,16 +1592,11 @@ class DeleteStreamKeyCommand 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("AmazonInteractiveVideoService", "DeleteStreamKey", {})
     .n("IvsClient", "DeleteStreamKeyCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteStreamKeyCommand)
-    .de(de_DeleteStreamKeyCommand)
+    .sc(DeleteStreamKey)
     .build() {
 }
 
@@ -1807,16 +1604,11 @@ class GetChannelCommand 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("AmazonInteractiveVideoService", "GetChannel", {})
     .n("IvsClient", "GetChannelCommand")
-    .f(void 0, GetChannelResponseFilterSensitiveLog)
-    .ser(se_GetChannelCommand)
-    .de(de_GetChannelCommand)
+    .sc(GetChannel)
     .build() {
 }
 
@@ -1824,16 +1616,11 @@ class GetPlaybackKeyPairCommand 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("AmazonInteractiveVideoService", "GetPlaybackKeyPair", {})
     .n("IvsClient", "GetPlaybackKeyPairCommand")
-    .f(void 0, void 0)
-    .ser(se_GetPlaybackKeyPairCommand)
-    .de(de_GetPlaybackKeyPairCommand)
+    .sc(GetPlaybackKeyPair)
     .build() {
 }
 
@@ -1841,16 +1628,11 @@ class GetPlaybackRestrictionPolicyCommand 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("AmazonInteractiveVideoService", "GetPlaybackRestrictionPolicy", {})
     .n("IvsClient", "GetPlaybackRestrictionPolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_GetPlaybackRestrictionPolicyCommand)
-    .de(de_GetPlaybackRestrictionPolicyCommand)
+    .sc(GetPlaybackRestrictionPolicy)
     .build() {
 }
 
@@ -1858,16 +1640,11 @@ class GetRecordingConfigurationCommand 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("AmazonInteractiveVideoService", "GetRecordingConfiguration", {})
     .n("IvsClient", "GetRecordingConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_GetRecordingConfigurationCommand)
-    .de(de_GetRecordingConfigurationCommand)
+    .sc(GetRecordingConfiguration)
     .build() {
 }
 
@@ -1875,16 +1652,11 @@ class GetStreamCommand 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("AmazonInteractiveVideoService", "GetStream", {})
     .n("IvsClient", "GetStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_GetStreamCommand)
-    .de(de_GetStreamCommand)
+    .sc(GetStream)
     .build() {
 }
 
@@ -1892,16 +1664,11 @@ class GetStreamKeyCommand 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("AmazonInteractiveVideoService", "GetStreamKey", {})
     .n("IvsClient", "GetStreamKeyCommand")
-    .f(void 0, GetStreamKeyResponseFilterSensitiveLog)
-    .ser(se_GetStreamKeyCommand)
-    .de(de_GetStreamKeyCommand)
+    .sc(GetStreamKey)
     .build() {
 }
 
@@ -1909,16 +1676,11 @@ class GetStreamSessionCommand 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("AmazonInteractiveVideoService", "GetStreamSession", {})
     .n("IvsClient", "GetStreamSessionCommand")
-    .f(void 0, GetStreamSessionResponseFilterSensitiveLog)
-    .ser(se_GetStreamSessionCommand)
-    .de(de_GetStreamSessionCommand)
+    .sc(GetStreamSession)
     .build() {
 }
 
@@ -1926,16 +1688,11 @@ class ImportPlaybackKeyPairCommand 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("AmazonInteractiveVideoService", "ImportPlaybackKeyPair", {})
     .n("IvsClient", "ImportPlaybackKeyPairCommand")
-    .f(void 0, void 0)
-    .ser(se_ImportPlaybackKeyPairCommand)
-    .de(de_ImportPlaybackKeyPairCommand)
+    .sc(ImportPlaybackKeyPair)
     .build() {
 }
 
@@ -1943,16 +1700,11 @@ class ListChannelsCommand 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("AmazonInteractiveVideoService", "ListChannels", {})
     .n("IvsClient", "ListChannelsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListChannelsCommand)
-    .de(de_ListChannelsCommand)
+    .sc(ListChannels)
     .build() {
 }
 
@@ -1960,16 +1712,11 @@ class ListPlaybackKeyPairsCommand 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("AmazonInteractiveVideoService", "ListPlaybackKeyPairs", {})
     .n("IvsClient", "ListPlaybackKeyPairsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListPlaybackKeyPairsCommand)
-    .de(de_ListPlaybackKeyPairsCommand)
+    .sc(ListPlaybackKeyPairs)
     .build() {
 }
 
@@ -1977,16 +1724,11 @@ class ListPlaybackRestrictionPoliciesCommand 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("AmazonInteractiveVideoService", "ListPlaybackRestrictionPolicies", {})
     .n("IvsClient", "ListPlaybackRestrictionPoliciesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListPlaybackRestrictionPoliciesCommand)
-    .de(de_ListPlaybackRestrictionPoliciesCommand)
+    .sc(ListPlaybackRestrictionPolicies)
     .build() {
 }
 
@@ -1994,16 +1736,11 @@ class ListRecordingConfigurationsCommand 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("AmazonInteractiveVideoService", "ListRecordingConfigurations", {})
     .n("IvsClient", "ListRecordingConfigurationsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListRecordingConfigurationsCommand)
-    .de(de_ListRecordingConfigurationsCommand)
+    .sc(ListRecordingConfigurations)
     .build() {
 }
 
@@ -2011,16 +1748,11 @@ class ListStreamKeysCommand 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("AmazonInteractiveVideoService", "ListStreamKeys", {})
     .n("IvsClient", "ListStreamKeysCommand")
-    .f(void 0, void 0)
-    .ser(se_ListStreamKeysCommand)
-    .de(de_ListStreamKeysCommand)
+    .sc(ListStreamKeys)
     .build() {
 }
 
@@ -2028,16 +1760,11 @@ class ListStreamsCommand 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("AmazonInteractiveVideoService", "ListStreams", {})
     .n("IvsClient", "ListStreamsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListStreamsCommand)
-    .de(de_ListStreamsCommand)
+    .sc(ListStreams)
     .build() {
 }
 
@@ -2045,16 +1772,11 @@ class ListStreamSessionsCommand 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("AmazonInteractiveVideoService", "ListStreamSessions", {})
     .n("IvsClient", "ListStreamSessionsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListStreamSessionsCommand)
-    .de(de_ListStreamSessionsCommand)
+    .sc(ListStreamSessions)
     .build() {
 }
 
@@ -2062,16 +1784,11 @@ class ListTagsForResourceCommand 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("AmazonInteractiveVideoService", "ListTagsForResource", {})
     .n("IvsClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -2079,16 +1796,11 @@ class PutMetadataCommand 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("AmazonInteractiveVideoService", "PutMetadata", {})
     .n("IvsClient", "PutMetadataCommand")
-    .f(PutMetadataRequestFilterSensitiveLog, void 0)
-    .ser(se_PutMetadataCommand)
-    .de(de_PutMetadataCommand)
+    .sc(PutMetadata)
     .build() {
 }
 
@@ -2096,16 +1808,11 @@ class StartViewerSessionRevocationCommand 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("AmazonInteractiveVideoService", "StartViewerSessionRevocation", {})
     .n("IvsClient", "StartViewerSessionRevocationCommand")
-    .f(void 0, void 0)
-    .ser(se_StartViewerSessionRevocationCommand)
-    .de(de_StartViewerSessionRevocationCommand)
+    .sc(StartViewerSessionRevocation)
     .build() {
 }
 
@@ -2113,16 +1820,11 @@ class StopStreamCommand 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("AmazonInteractiveVideoService", "StopStream", {})
     .n("IvsClient", "StopStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_StopStreamCommand)
-    .de(de_StopStreamCommand)
+    .sc(StopStream)
     .build() {
 }
 
@@ -2130,16 +1832,11 @@ class TagResourceCommand 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("AmazonInteractiveVideoService", "TagResource", {})
     .n("IvsClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -2147,16 +1844,11 @@ class UntagResourceCommand 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("AmazonInteractiveVideoService", "UntagResource", {})
     .n("IvsClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -2164,16 +1856,11 @@ class UpdateChannelCommand 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("AmazonInteractiveVideoService", "UpdateChannel", {})
     .n("IvsClient", "UpdateChannelCommand")
-    .f(void 0, UpdateChannelResponseFilterSensitiveLog)
-    .ser(se_UpdateChannelCommand)
-    .de(de_UpdateChannelCommand)
+    .sc(UpdateChannel)
     .build() {
 }
 
@@ -2181,16 +1868,11 @@ class UpdatePlaybackRestrictionPolicyCommand 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("AmazonInteractiveVideoService", "UpdatePlaybackRestrictionPolicy", {})
     .n("IvsClient", "UpdatePlaybackRestrictionPolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdatePlaybackRestrictionPolicyCommand)
-    .de(de_UpdatePlaybackRestrictionPolicyCommand)
+    .sc(UpdatePlaybackRestrictionPolicy)
     .build() {
 }
 
@@ -2257,44 +1939,36 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.BatchGetChannelCommand = BatchGetChannelCommand;
-exports.BatchGetChannelResponseFilterSensitiveLog = BatchGetChannelResponseFilterSensitiveLog;
 exports.BatchGetStreamKeyCommand = BatchGetStreamKeyCommand;
-exports.BatchGetStreamKeyResponseFilterSensitiveLog = BatchGetStreamKeyResponseFilterSensitiveLog;
 exports.BatchStartViewerSessionRevocationCommand = BatchStartViewerSessionRevocationCommand;
-exports.ChannelFilterSensitiveLog = ChannelFilterSensitiveLog;
 exports.ChannelLatencyMode = ChannelLatencyMode;
-exports.ChannelNotBroadcasting = ChannelNotBroadcasting;
+exports.ChannelNotBroadcasting = ChannelNotBroadcasting$1;
 exports.ChannelType = ChannelType;
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.ContainerFormat = ContainerFormat;
 exports.CreateChannelCommand = CreateChannelCommand;
-exports.CreateChannelResponseFilterSensitiveLog = CreateChannelResponseFilterSensitiveLog;
 exports.CreatePlaybackRestrictionPolicyCommand = CreatePlaybackRestrictionPolicyCommand;
 exports.CreateRecordingConfigurationCommand = CreateRecordingConfigurationCommand;
 exports.CreateStreamKeyCommand = CreateStreamKeyCommand;
-exports.CreateStreamKeyResponseFilterSensitiveLog = CreateStreamKeyResponseFilterSensitiveLog;
 exports.DeleteChannelCommand = DeleteChannelCommand;
 exports.DeletePlaybackKeyPairCommand = DeletePlaybackKeyPairCommand;
 exports.DeletePlaybackRestrictionPolicyCommand = DeletePlaybackRestrictionPolicyCommand;
 exports.DeleteRecordingConfigurationCommand = DeleteRecordingConfigurationCommand;
 exports.DeleteStreamKeyCommand = DeleteStreamKeyCommand;
 exports.GetChannelCommand = GetChannelCommand;
-exports.GetChannelResponseFilterSensitiveLog = GetChannelResponseFilterSensitiveLog;
 exports.GetPlaybackKeyPairCommand = GetPlaybackKeyPairCommand;
 exports.GetPlaybackRestrictionPolicyCommand = GetPlaybackRestrictionPolicyCommand;
 exports.GetRecordingConfigurationCommand = GetRecordingConfigurationCommand;
 exports.GetStreamCommand = GetStreamCommand;
 exports.GetStreamKeyCommand = GetStreamKeyCommand;
-exports.GetStreamKeyResponseFilterSensitiveLog = GetStreamKeyResponseFilterSensitiveLog;
 exports.GetStreamSessionCommand = GetStreamSessionCommand;
-exports.GetStreamSessionResponseFilterSensitiveLog = GetStreamSessionResponseFilterSensitiveLog;
 exports.ImportPlaybackKeyPairCommand = ImportPlaybackKeyPairCommand;
-exports.InternalServerException = InternalServerException;
+exports.InternalServerException = InternalServerException$1;
 exports.Ivs = Ivs;
 exports.IvsClient = IvsClient;
-exports.IvsServiceException = IvsServiceException;
+exports.IvsServiceException = IvsServiceException$1;
 exports.ListChannelsCommand = ListChannelsCommand;
 exports.ListPlaybackKeyPairsCommand = ListPlaybackKeyPairsCommand;
 exports.ListPlaybackRestrictionPoliciesCommand = ListPlaybackRestrictionPoliciesCommand;
@@ -2305,33 +1979,28 @@ exports.ListStreamsCommand = ListStreamsCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.MultitrackMaximumResolution = MultitrackMaximumResolution;
 exports.MultitrackPolicy = MultitrackPolicy;
-exports.PendingVerification = PendingVerification;
+exports.PendingVerification = PendingVerification$1;
 exports.PutMetadataCommand = PutMetadataCommand;
-exports.PutMetadataRequestFilterSensitiveLog = PutMetadataRequestFilterSensitiveLog;
 exports.RecordingConfigurationState = RecordingConfigurationState;
 exports.RecordingMode = RecordingMode;
 exports.RenditionConfigurationRendition = RenditionConfigurationRendition;
 exports.RenditionConfigurationRenditionSelection = RenditionConfigurationRenditionSelection;
-exports.ResourceNotFoundException = ResourceNotFoundException;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
-exports.SrtFilterSensitiveLog = SrtFilterSensitiveLog;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.StartViewerSessionRevocationCommand = StartViewerSessionRevocationCommand;
 exports.StopStreamCommand = StopStreamCommand;
 exports.StreamHealth = StreamHealth;
-exports.StreamKeyFilterSensitiveLog = StreamKeyFilterSensitiveLog;
-exports.StreamSessionFilterSensitiveLog = StreamSessionFilterSensitiveLog;
 exports.StreamState = StreamState;
-exports.StreamUnavailable = StreamUnavailable;
+exports.StreamUnavailable = StreamUnavailable$1;
 exports.TagResourceCommand = TagResourceCommand;
-exports.ThrottlingException = ThrottlingException;
+exports.ThrottlingException = ThrottlingException$1;
 exports.ThumbnailConfigurationResolution = ThumbnailConfigurationResolution;
 exports.ThumbnailConfigurationStorage = ThumbnailConfigurationStorage;
 exports.TranscodePreset = TranscodePreset;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateChannelCommand = UpdateChannelCommand;
-exports.UpdateChannelResponseFilterSensitiveLog = UpdateChannelResponseFilterSensitiveLog;
 exports.UpdatePlaybackRestrictionPolicyCommand = UpdatePlaybackRestrictionPolicyCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.paginateListChannels = paginateListChannels;
 exports.paginateListPlaybackKeyPairs = paginateListPlaybackKeyPairs;
 exports.paginateListPlaybackRestrictionPolicies = paginateListPlaybackRestrictionPolicies;