@aws-sdk/client-ivs-realtime 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,9 +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');
-var uuid = require('@smithy/uuid');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -92,6 +90,7 @@ class IVSRealTimeClient 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));
@@ -111,14 +110,14 @@ class IVSRealTimeClient extends smithyClient.Client {
     }
 }
 
-class IVSRealTimeServiceException extends smithyClient.ServiceException {
+let IVSRealTimeServiceException$1 = class IVSRealTimeServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, IVSRealTimeServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends IVSRealTimeServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends IVSRealTimeServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     accessControlAllowOrigin;
@@ -147,8 +146,8 @@ class AccessDeniedException extends IVSRealTimeServiceException {
         this.xAmznErrorType = opts.xAmznErrorType;
         this.exceptionMessage = opts.exceptionMessage;
     }
-}
-class ConflictException extends IVSRealTimeServiceException {
+};
+let ConflictException$1 = class ConflictException extends IVSRealTimeServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     accessControlAllowOrigin;
@@ -177,8 +176,8 @@ class ConflictException extends IVSRealTimeServiceException {
         this.xAmznErrorType = opts.xAmznErrorType;
         this.exceptionMessage = opts.exceptionMessage;
     }
-}
-class InternalServerException extends IVSRealTimeServiceException {
+};
+let InternalServerException$1 = class InternalServerException extends IVSRealTimeServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     accessControlAllowOrigin;
@@ -207,8 +206,8 @@ class InternalServerException extends IVSRealTimeServiceException {
         this.xAmznErrorType = opts.xAmznErrorType;
         this.exceptionMessage = opts.exceptionMessage;
     }
-}
-class PendingVerification extends IVSRealTimeServiceException {
+};
+let PendingVerification$1 = class PendingVerification extends IVSRealTimeServiceException$1 {
     name = "PendingVerification";
     $fault = "client";
     accessControlAllowOrigin;
@@ -237,8 +236,8 @@ class PendingVerification extends IVSRealTimeServiceException {
         this.xAmznErrorType = opts.xAmznErrorType;
         this.exceptionMessage = opts.exceptionMessage;
     }
-}
-class ResourceNotFoundException extends IVSRealTimeServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends IVSRealTimeServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     accessControlAllowOrigin;
@@ -267,8 +266,8 @@ class ResourceNotFoundException extends IVSRealTimeServiceException {
         this.xAmznErrorType = opts.xAmznErrorType;
         this.exceptionMessage = opts.exceptionMessage;
     }
-}
-class ServiceQuotaExceededException extends IVSRealTimeServiceException {
+};
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends IVSRealTimeServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     accessControlAllowOrigin;
@@ -297,8 +296,8 @@ class ServiceQuotaExceededException extends IVSRealTimeServiceException {
         this.xAmznErrorType = opts.xAmznErrorType;
         this.exceptionMessage = opts.exceptionMessage;
     }
-}
-class ValidationException extends IVSRealTimeServiceException {
+};
+let ValidationException$1 = class ValidationException extends IVSRealTimeServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     accessControlAllowOrigin;
@@ -327,7 +326,7 @@ class ValidationException extends IVSRealTimeServiceException {
         this.xAmznErrorType = opts.xAmznErrorType;
         this.exceptionMessage = opts.exceptionMessage;
     }
-}
+};
 const IngestProtocol = {
     RTMP: "RTMP",
     RTMPS: "RTMPS",
@@ -455,1563 +454,1783 @@ const ParticipantRecordingFilterByRecordingState = {
     STOPPED: "STOPPED",
     STOPPING: "STOPPING",
 };
-const IngestConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.streamKey && { streamKey: smithyClient.SENSITIVE_STRING }),
-});
-const CreateIngestConfigurationResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.ingestConfiguration && {
-        ingestConfiguration: IngestConfigurationFilterSensitiveLog(obj.ingestConfiguration),
-    }),
-});
-const ParticipantTokenFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.token && { token: smithyClient.SENSITIVE_STRING }),
-});
-const CreateParticipantTokenResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.participantToken && { participantToken: ParticipantTokenFilterSensitiveLog(obj.participantToken) }),
-});
-const CreateStageResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.participantTokens && {
-        participantTokens: obj.participantTokens.map((item) => ParticipantTokenFilterSensitiveLog(item)),
-    }),
-});
-const GetIngestConfigurationResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.ingestConfiguration && {
-        ingestConfiguration: IngestConfigurationFilterSensitiveLog(obj.ingestConfiguration),
-    }),
-});
-const UpdateIngestConfigurationResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.ingestConfiguration && {
-        ingestConfiguration: IngestConfigurationFilterSensitiveLog(obj.ingestConfiguration),
-    }),
-});
 
-const se_CreateEncoderConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/CreateEncoderConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        name: [],
-        tags: (_) => smithyClient._json(_),
-        video: (_) => se_Video(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateIngestConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/CreateIngestConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        attributes: (_) => smithyClient._json(_),
-        ingestProtocol: [],
-        insecureIngest: [],
-        name: [],
-        stageArn: [],
-        tags: (_) => smithyClient._json(_),
-        userId: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateParticipantTokenCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/CreateParticipantToken");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        attributes: (_) => smithyClient._json(_),
-        capabilities: (_) => smithyClient._json(_),
-        duration: [],
-        stageArn: [],
-        userId: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateStageCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/CreateStage");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        autoParticipantRecordingConfiguration: (_) => smithyClient._json(_),
-        name: [],
-        participantTokenConfigurations: (_) => smithyClient._json(_),
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateStorageConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/CreateStorageConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        name: [],
-        s3: (_) => smithyClient._json(_),
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteEncoderConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeleteEncoderConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteIngestConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeleteIngestConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-        force: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeletePublicKeyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeletePublicKey");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteStageCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeleteStage");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteStorageConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeleteStorageConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DisconnectParticipantCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DisconnectParticipant");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        participantId: [],
-        reason: [],
-        stageArn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetCompositionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetComposition");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetEncoderConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetEncoderConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetIngestConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetIngestConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetParticipantCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetParticipant");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        participantId: [],
-        sessionId: [],
-        stageArn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetPublicKeyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetPublicKey");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetStageCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetStage");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetStageSessionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetStageSession");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        sessionId: [],
-        stageArn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetStorageConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetStorageConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ImportPublicKeyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ImportPublicKey");
-    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_ListCompositionsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListCompositions");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        filterByEncoderConfigurationArn: [],
-        filterByStageArn: [],
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListEncoderConfigurationsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListEncoderConfigurations");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListIngestConfigurationsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListIngestConfigurations");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        filterByStageArn: [],
-        filterByState: [],
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListParticipantEventsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListParticipantEvents");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        maxResults: [],
-        nextToken: [],
-        participantId: [],
-        sessionId: [],
-        stageArn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListParticipantReplicasCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListParticipantReplicas");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        maxResults: [],
-        nextToken: [],
-        participantId: [],
-        sourceStageArn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListParticipantsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListParticipants");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        filterByPublished: [],
-        filterByRecordingState: [],
-        filterByState: [],
-        filterByUserId: [],
-        maxResults: [],
-        nextToken: [],
-        sessionId: [],
-        stageArn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListPublicKeysCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListPublicKeys");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListStagesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListStages");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListStageSessionsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListStageSessions");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        maxResults: [],
-        nextToken: [],
-        stageArn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListStorageConfigurationsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListStorageConfigurations");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        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_StartCompositionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/StartComposition");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        destinations: (_) => smithyClient._json(_),
-        idempotencyToken: [true, (_) => _ ?? uuid.v4()],
-        layout: (_) => smithyClient._json(_),
-        stageArn: [],
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StartParticipantReplicationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/StartParticipantReplication");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        attributes: (_) => smithyClient._json(_),
-        destinationStageArn: [],
-        participantId: [],
-        reconnectWindowSeconds: [],
-        sourceStageArn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StopCompositionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/StopComposition");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StopParticipantReplicationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/StopParticipantReplication");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        destinationStageArn: [],
-        participantId: [],
-        sourceStageArn: [],
-    }));
-    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_UpdateIngestConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/UpdateIngestConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-        stageArn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateStageCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/UpdateStage");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        arn: [],
-        autoParticipantRecordingConfiguration: (_) => smithyClient._json(_),
-        name: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const de_CreateEncoderConfigurationCommand = 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, {
-        encoderConfiguration: (_) => de_EncoderConfiguration(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateIngestConfigurationCommand = 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, {
-        ingestConfiguration: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateParticipantTokenCommand = 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, {
-        participantToken: (_) => de_ParticipantToken(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateStageCommand = 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, {
-        participantTokens: (_) => de_ParticipantTokenList(_),
-        stage: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateStorageConfigurationCommand = 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, {
-        storageConfiguration: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteEncoderConfigurationCommand = 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_DeleteIngestConfigurationCommand = 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_DeletePublicKeyCommand = 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_DeleteStageCommand = 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_DeleteStorageConfigurationCommand = 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_DisconnectParticipantCommand = 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_GetCompositionCommand = 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, {
-        composition: (_) => de_Composition(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetEncoderConfigurationCommand = 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, {
-        encoderConfiguration: (_) => de_EncoderConfiguration(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetIngestConfigurationCommand = 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, {
-        ingestConfiguration: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetParticipantCommand = 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, {
-        participant: (_) => de_Participant(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetPublicKeyCommand = 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, {
-        publicKey: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetStageCommand = 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, {
-        stage: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetStageSessionCommand = 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, {
-        stageSession: (_) => de_StageSession(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetStorageConfigurationCommand = 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, {
-        storageConfiguration: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ImportPublicKeyCommand = 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, {
-        publicKey: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListCompositionsCommand = 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, {
-        compositions: (_) => de_CompositionSummaryList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListEncoderConfigurationsCommand = 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, {
-        encoderConfigurations: smithyClient._json,
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListIngestConfigurationsCommand = 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, {
-        ingestConfigurations: smithyClient._json,
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListParticipantEventsCommand = 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, {
-        events: (_) => de_EventList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListParticipantReplicasCommand = 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,
-        replicas: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListParticipantsCommand = 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,
-        participants: (_) => de_ParticipantList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListPublicKeysCommand = 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,
-        publicKeys: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListStagesCommand = 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,
-        stages: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListStageSessionsCommand = 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,
-        stageSessions: (_) => de_StageSessionList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListStorageConfigurationsCommand = 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,
-        storageConfigurations: smithyClient._json,
-    });
-    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_StartCompositionCommand = 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, {
-        composition: (_) => de_Composition(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartParticipantReplicationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_aCAO]: [, output.headers[_acao]],
-        [_aCEH]: [, output.headers[_aceh]],
-        [_cC]: [, output.headers[_cc]],
-        [_cSP]: [, output.headers[_csp]],
-        [_sTS]: [, output.headers[_sts]],
-        [_xCTO]: [, output.headers[_xcto]],
-        [_xFO]: [, output.headers[_xfo]],
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_StopCompositionCommand = 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_StopParticipantReplicationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_aCAO]: [, output.headers[_acao]],
-        [_aCEH]: [, output.headers[_aceh]],
-        [_cC]: [, output.headers[_cc]],
-        [_cSP]: [, output.headers[_csp]],
-        [_sTS]: [, output.headers[_sts]],
-        [_xCTO]: [, output.headers[_xcto]],
-        [_xFO]: [, output.headers[_xfo]],
-    });
-    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_UpdateIngestConfigurationCommand = 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, {
-        ingestConfiguration: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateStageCommand = 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, {
-        stage: 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.ivsrealtime#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.ivsrealtime#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.ivsrealtime#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "PendingVerification":
-        case "com.amazonaws.ivsrealtime#PendingVerification":
-            throw await de_PendingVerificationRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.ivsrealtime#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.ivsrealtime#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(IVSRealTimeServiceException);
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({
-        [_aCAO]: [, parsedOutput.headers[_acao]],
-        [_aCEH]: [, parsedOutput.headers[_aceh]],
-        [_cC]: [, parsedOutput.headers[_cc]],
-        [_cSP]: [, parsedOutput.headers[_csp]],
-        [_sTS]: [, parsedOutput.headers[_sts]],
-        [_xCTO]: [, parsedOutput.headers[_xcto]],
-        [_xFO]: [, parsedOutput.headers[_xfo]],
-        [_xAET]: [, parsedOutput.headers[_xae]],
-    });
-    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_ConflictExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({
-        [_aCAO]: [, parsedOutput.headers[_acao]],
-        [_aCEH]: [, parsedOutput.headers[_aceh]],
-        [_cC]: [, parsedOutput.headers[_cc]],
-        [_cSP]: [, parsedOutput.headers[_csp]],
-        [_sTS]: [, parsedOutput.headers[_sts]],
-        [_xCTO]: [, parsedOutput.headers[_xcto]],
-        [_xFO]: [, parsedOutput.headers[_xfo]],
-        [_xAET]: [, parsedOutput.headers[_xae]],
-    });
-    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({
-        [_aCAO]: [, parsedOutput.headers[_acao]],
-        [_aCEH]: [, parsedOutput.headers[_aceh]],
-        [_cC]: [, parsedOutput.headers[_cc]],
-        [_cSP]: [, parsedOutput.headers[_csp]],
-        [_sTS]: [, parsedOutput.headers[_sts]],
-        [_xCTO]: [, parsedOutput.headers[_xcto]],
-        [_xFO]: [, parsedOutput.headers[_xfo]],
-        [_xAET]: [, parsedOutput.headers[_xae]],
-    });
-    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({
-        [_aCAO]: [, parsedOutput.headers[_acao]],
-        [_aCEH]: [, parsedOutput.headers[_aceh]],
-        [_cC]: [, parsedOutput.headers[_cc]],
-        [_cSP]: [, parsedOutput.headers[_csp]],
-        [_sTS]: [, parsedOutput.headers[_sts]],
-        [_xCTO]: [, parsedOutput.headers[_xcto]],
-        [_xFO]: [, parsedOutput.headers[_xfo]],
-        [_xAET]: [, parsedOutput.headers[_xae]],
-    });
-    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({
-        [_aCAO]: [, parsedOutput.headers[_acao]],
-        [_aCEH]: [, parsedOutput.headers[_aceh]],
-        [_cC]: [, parsedOutput.headers[_cc]],
-        [_cSP]: [, parsedOutput.headers[_csp]],
-        [_sTS]: [, parsedOutput.headers[_sts]],
-        [_xCTO]: [, parsedOutput.headers[_xcto]],
-        [_xFO]: [, parsedOutput.headers[_xfo]],
-        [_xAET]: [, parsedOutput.headers[_xae]],
-    });
-    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({
-        [_aCAO]: [, parsedOutput.headers[_acao]],
-        [_aCEH]: [, parsedOutput.headers[_aceh]],
-        [_cC]: [, parsedOutput.headers[_cc]],
-        [_cSP]: [, parsedOutput.headers[_csp]],
-        [_sTS]: [, parsedOutput.headers[_sts]],
-        [_xCTO]: [, parsedOutput.headers[_xcto]],
-        [_xFO]: [, parsedOutput.headers[_xfo]],
-        [_xAET]: [, parsedOutput.headers[_xae]],
-    });
-    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_ValidationExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({
-        [_aCAO]: [, parsedOutput.headers[_acao]],
-        [_aCEH]: [, parsedOutput.headers[_aceh]],
-        [_cC]: [, parsedOutput.headers[_cc]],
-        [_cSP]: [, parsedOutput.headers[_csp]],
-        [_sTS]: [, parsedOutput.headers[_sts]],
-        [_xCTO]: [, parsedOutput.headers[_xcto]],
-        [_xFO]: [, parsedOutput.headers[_xfo]],
-        [_xAET]: [, parsedOutput.headers[_xae]],
-    });
-    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 se_Video = (input, context) => {
-    return smithyClient.take(input, {
-        bitrate: [],
-        framerate: smithyClient.serializeFloat,
-        height: [],
-        width: [],
-    });
-};
-const de_Composition = (output, context) => {
-    return smithyClient.take(output, {
-        arn: smithyClient.expectString,
-        destinations: (_) => de_DestinationList(_),
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        layout: smithyClient._json,
-        stageArn: smithyClient.expectString,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        state: smithyClient.expectString,
-        tags: smithyClient._json,
-    });
-};
-const de_CompositionSummary = (output, context) => {
-    return smithyClient.take(output, {
-        arn: smithyClient.expectString,
-        destinations: (_) => de_DestinationSummaryList(_),
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        stageArn: smithyClient.expectString,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        state: smithyClient.expectString,
-        tags: smithyClient._json,
-    });
-};
-const de_CompositionSummaryList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_CompositionSummary(entry);
-    });
-    return retVal;
-};
-const de_Destination = (output, context) => {
-    return smithyClient.take(output, {
-        configuration: smithyClient._json,
-        detail: smithyClient._json,
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        id: smithyClient.expectString,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        state: smithyClient.expectString,
-    });
-};
-const de_DestinationList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Destination(entry);
-    });
-    return retVal;
-};
-const de_DestinationSummary = (output, context) => {
-    return smithyClient.take(output, {
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        id: smithyClient.expectString,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        state: smithyClient.expectString,
-    });
-};
-const de_DestinationSummaryList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_DestinationSummary(entry);
-    });
-    return retVal;
-};
-const de_EncoderConfiguration = (output, context) => {
-    return smithyClient.take(output, {
-        arn: smithyClient.expectString,
-        name: smithyClient.expectString,
-        tags: smithyClient._json,
-        video: (_) => de_Video(_),
-    });
-};
-const de_Event = (output, context) => {
-    return smithyClient.take(output, {
-        destinationSessionId: smithyClient.expectString,
-        destinationStageArn: smithyClient.expectString,
-        errorCode: smithyClient.expectString,
-        eventTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        name: smithyClient.expectString,
-        participantId: smithyClient.expectString,
-        remoteParticipantId: smithyClient.expectString,
-        replica: smithyClient.expectBoolean,
-    });
-};
-const de_EventList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Event(entry);
-    });
-    return retVal;
-};
-const de_Participant = (output, context) => {
-    return smithyClient.take(output, {
-        attributes: smithyClient._json,
-        browserName: smithyClient.expectString,
-        browserVersion: smithyClient.expectString,
-        firstJoinTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        ispName: smithyClient.expectString,
-        osName: smithyClient.expectString,
-        osVersion: smithyClient.expectString,
-        participantId: smithyClient.expectString,
-        protocol: smithyClient.expectString,
-        published: smithyClient.expectBoolean,
-        recordingS3BucketName: smithyClient.expectString,
-        recordingS3Prefix: smithyClient.expectString,
-        recordingState: smithyClient.expectString,
-        replicationState: smithyClient.expectString,
-        replicationType: smithyClient.expectString,
-        sdkVersion: smithyClient.expectString,
-        sourceSessionId: smithyClient.expectString,
-        sourceStageArn: smithyClient.expectString,
-        state: smithyClient.expectString,
-        userId: smithyClient.expectString,
-    });
-};
-const de_ParticipantList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ParticipantSummary(entry);
-    });
-    return retVal;
-};
-const de_ParticipantSummary = (output, context) => {
-    return smithyClient.take(output, {
-        firstJoinTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        participantId: smithyClient.expectString,
-        published: smithyClient.expectBoolean,
-        recordingState: smithyClient.expectString,
-        replicationState: smithyClient.expectString,
-        replicationType: smithyClient.expectString,
-        sourceSessionId: smithyClient.expectString,
-        sourceStageArn: smithyClient.expectString,
-        state: smithyClient.expectString,
-        userId: smithyClient.expectString,
-    });
-};
-const de_ParticipantToken = (output, context) => {
-    return smithyClient.take(output, {
-        attributes: smithyClient._json,
-        capabilities: smithyClient._json,
-        duration: smithyClient.expectInt32,
-        expirationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        participantId: smithyClient.expectString,
-        token: smithyClient.expectString,
-        userId: smithyClient.expectString,
-    });
-};
-const de_ParticipantTokenList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ParticipantToken(entry);
-    });
-    return retVal;
-};
-const de_StageSession = (output, context) => {
-    return smithyClient.take(output, {
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        sessionId: smithyClient.expectString,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-    });
-};
-const de_StageSessionList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_StageSessionSummary(entry);
-    });
-    return retVal;
-};
-const de_StageSessionSummary = (output, context) => {
-    return smithyClient.take(output, {
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        sessionId: smithyClient.expectString,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-    });
-};
-const de_Video = (output, context) => {
-    return smithyClient.take(output, {
-        bitrate: smithyClient.expectInt32,
-        framerate: smithyClient.limitedParseFloat32,
-        height: smithyClient.expectInt32,
-        width: smithyClient.expectInt32,
-    });
-};
-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 _ACAO = "Access-Control-Allow-Origin";
+const _ACEH = "Access-Control-Expose-Headers";
+const _ADE = "AccessDeniedException";
+const _APRC = "AutoParticipantRecordingConfiguration";
+const _C = "Composition";
+const _CC = "Cache-Control";
+const _CDC = "ChannelDestinationConfiguration";
+const _CE = "ConflictException";
+const _CEC = "CreateEncoderConfiguration";
+const _CECR = "CreateEncoderConfigurationRequest";
+const _CECRr = "CreateEncoderConfigurationResponse";
+const _CIC = "CreateIngestConfiguration";
+const _CICR = "CreateIngestConfigurationRequest";
+const _CICRr = "CreateIngestConfigurationResponse";
+const _CPT = "CreateParticipantToken";
+const _CPTR = "CreateParticipantTokenRequest";
+const _CPTRr = "CreateParticipantTokenResponse";
+const _CRHC = "CompositionRecordingHlsConfiguration";
+const _CS = "CompositionSummary";
+const _CSC = "CreateStorageConfiguration";
+const _CSCR = "CreateStorageConfigurationRequest";
+const _CSCRr = "CreateStorageConfigurationResponse";
+const _CSL = "CompositionSummaryList";
+const _CSP = "Content-Security-Policy";
+const _CSR = "CreateStageRequest";
+const _CSRr = "CreateStageResponse";
+const _CSr = "CreateStage";
+const _CTC = "CompositionThumbnailConfiguration";
+const _CTCL = "CompositionThumbnailConfigurationList";
+const _D = "Destination";
+const _DC = "DestinationConfiguration";
+const _DCL = "DestinationConfigurationList";
+const _DD = "DestinationDetail";
+const _DEC = "DeleteEncoderConfiguration";
+const _DECR = "DeleteEncoderConfigurationRequest";
+const _DECRe = "DeleteEncoderConfigurationResponse";
+const _DIC = "DeleteIngestConfiguration";
+const _DICR = "DeleteIngestConfigurationRequest";
+const _DICRe = "DeleteIngestConfigurationResponse";
+const _DL = "DestinationList";
+const _DP = "DisconnectParticipant";
+const _DPK = "DeletePublicKey";
+const _DPKR = "DeletePublicKeyRequest";
+const _DPKRe = "DeletePublicKeyResponse";
+const _DPR = "DisconnectParticipantRequest";
+const _DPRi = "DisconnectParticipantResponse";
+const _DS = "DestinationSummary";
+const _DSC = "DeleteStorageConfiguration";
+const _DSCR = "DeleteStorageConfigurationRequest";
+const _DSCRe = "DeleteStorageConfigurationResponse";
+const _DSL = "DestinationSummaryList";
+const _DSR = "DeleteStageRequest";
+const _DSRe = "DeleteStageResponse";
+const _DSe = "DeleteStage";
+const _E = "Event";
+const _EC = "EncoderConfiguration";
+const _ECS = "EncoderConfigurationSummary";
+const _ECSL = "EncoderConfigurationSummaryList";
+const _EL = "EventList";
+const _GC = "GridConfiguration";
+const _GCR = "GetCompositionRequest";
+const _GCRe = "GetCompositionResponse";
+const _GCe = "GetComposition";
+const _GEC = "GetEncoderConfiguration";
+const _GECR = "GetEncoderConfigurationRequest";
+const _GECRe = "GetEncoderConfigurationResponse";
+const _GIC = "GetIngestConfiguration";
+const _GICR = "GetIngestConfigurationRequest";
+const _GICRe = "GetIngestConfigurationResponse";
+const _GP = "GetParticipant";
+const _GPK = "GetPublicKey";
+const _GPKR = "GetPublicKeyRequest";
+const _GPKRe = "GetPublicKeyResponse";
+const _GPR = "GetParticipantRequest";
+const _GPRe = "GetParticipantResponse";
+const _GS = "GetStage";
+const _GSC = "GetStorageConfiguration";
+const _GSCR = "GetStorageConfigurationRequest";
+const _GSCRe = "GetStorageConfigurationResponse";
+const _GSR = "GetStageRequest";
+const _GSRe = "GetStageResponse";
+const _GSS = "GetStageSession";
+const _GSSR = "GetStageSessionRequest";
+const _GSSRe = "GetStageSessionResponse";
+const _IC = "IngestConfiguration";
+const _ICL = "IngestConfigurationList";
+const _ICS = "IngestConfigurationSummary";
+const _IPK = "ImportPublicKey";
+const _IPKR = "ImportPublicKeyRequest";
+const _IPKRm = "ImportPublicKeyResponse";
+const _ISE = "InternalServerException";
+const _LC = "LayoutConfiguration";
+const _LCR = "ListCompositionsRequest";
+const _LCRi = "ListCompositionsResponse";
+const _LCi = "ListCompositions";
+const _LEC = "ListEncoderConfigurations";
+const _LECR = "ListEncoderConfigurationsRequest";
+const _LECRi = "ListEncoderConfigurationsResponse";
+const _LIC = "ListIngestConfigurations";
+const _LICR = "ListIngestConfigurationsRequest";
+const _LICRi = "ListIngestConfigurationsResponse";
+const _LP = "ListParticipants";
+const _LPE = "ListParticipantEvents";
+const _LPER = "ListParticipantEventsRequest";
+const _LPERi = "ListParticipantEventsResponse";
+const _LPK = "ListPublicKeys";
+const _LPKR = "ListPublicKeysRequest";
+const _LPKRi = "ListPublicKeysResponse";
+const _LPR = "ListParticipantsRequest";
+const _LPRR = "ListParticipantReplicasRequest";
+const _LPRRi = "ListParticipantReplicasResponse";
+const _LPRi = "ListParticipantsResponse";
+const _LPRis = "ListParticipantReplicas";
+const _LS = "ListStages";
+const _LSC = "ListStorageConfigurations";
+const _LSCR = "ListStorageConfigurationsRequest";
+const _LSCRi = "ListStorageConfigurationsResponse";
+const _LSR = "ListStagesRequest";
+const _LSRi = "ListStagesResponse";
+const _LSS = "ListStageSessions";
+const _LSSR = "ListStageSessionsRequest";
+const _LSSRi = "ListStageSessionsResponse";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _P = "Participant";
+const _PC = "PipConfiguration";
+const _PK = "PublicKey";
+const _PKL = "PublicKeyList";
+const _PKS = "PublicKeySummary";
+const _PL = "ParticipantList";
+const _PR = "ParticipantReplica";
+const _PRHC = "ParticipantRecordingHlsConfiguration";
+const _PRL = "ParticipantReplicaList";
+const _PS = "ParticipantSummary";
+const _PT = "ParticipantToken";
+const _PTC = "ParticipantThumbnailConfiguration";
+const _PTCa = "ParticipantTokenConfiguration";
+const _PTCar = "ParticipantTokenConfigurations";
+const _PTL = "ParticipantTokenList";
+const _PTS = "ParticipantTokenString";
+const _PV = "PendingVerification";
+const _RC = "RecordingConfiguration";
+const _RNFE = "ResourceNotFoundException";
+const _S = "Stage";
+const _SC = "StorageConfiguration";
+const _SCR = "StartCompositionRequest";
+const _SCRt = "StartCompositionResponse";
+const _SCRto = "StopCompositionRequest";
+const _SCRtop = "StopCompositionResponse";
+const _SCS = "StorageConfigurationSummary";
+const _SCSL = "StorageConfigurationSummaryList";
+const _SCt = "StartComposition";
+const _SCto = "StopComposition";
+const _SD = "S3Detail";
+const _SDC = "S3DestinationConfiguration";
+const _SE = "StageEndpoints";
+const _SK = "StreamKey";
+const _SPR = "StartParticipantReplication";
+const _SPRR = "StartParticipantReplicationRequest";
+const _SPRRt = "StartParticipantReplicationResponse";
+const _SPRRto = "StopParticipantReplicationRequest";
+const _SPRRtop = "StopParticipantReplicationResponse";
+const _SPRt = "StopParticipantReplication";
+const _SQEE = "ServiceQuotaExceededException";
+const _SS = "StageSession";
+const _SSC = "S3StorageConfiguration";
+const _SSL = "StageSessionList";
+const _SSLt = "StageSummaryList";
+const _SSS = "StageSessionSummary";
+const _SSt = "StageSummary";
+const _STS = "Strict-Transport-Security";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _UIC = "UpdateIngestConfiguration";
+const _UICR = "UpdateIngestConfigurationRequest";
+const _UICRp = "UpdateIngestConfigurationResponse";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _US = "UpdateStage";
+const _USR = "UpdateStageRequest";
+const _USRp = "UpdateStageResponse";
+const _V = "Video";
+const _VE = "ValidationException";
+const _XCTO = "X-Content-Type-Options";
+const _XFO = "X-Frame-Options";
+const _a = "arn";
 const _aCAO = "accessControlAllowOrigin";
 const _aCEH = "accessControlExposeHeaders";
-const _acao = "access-control-allow-origin";
-const _aceh = "access-control-expose-headers";
+const _aPRC = "autoParticipantRecordingConfiguration";
+const _aSI = "activeSessionId";
+const _at = "attributes";
+const _b = "bitrate";
+const _bN = "browserName";
+const _bNu = "bucketName";
+const _bV = "browserVersion";
+const _c = "client";
+const _cA = "channelArn";
 const _cC = "cacheControl";
 const _cSP = "contentSecurityPolicy";
-const _cc = "cache-control";
-const _csp = "content-security-policy";
+const _ca = "capabilities";
+const _ch = "channel";
+const _co = "configuration";
+const _com = "composition";
+const _comp = "compositions";
+const _d = "destinations";
+const _dSA = "destinationStageArn";
+const _dSI = "destinationSessionId";
+const _de = "detail";
+const _du = "duration";
+const _e = "error";
+const _eC = "encoderConfiguration";
+const _eCA = "encoderConfigurationArn";
+const _eCAn = "encoderConfigurationArns";
+const _eCn = "encoderConfigurations";
+const _eCr = "errorCode";
+const _eM = "exceptionMessage";
+const _eT = "endTime";
+const _eTv = "eventTime";
+const _eTx = "expirationTime";
+const _en = "endpoints";
+const _ev = "events";
+const _f = "force";
+const _fBECA = "filterByEncoderConfigurationArn";
+const _fBP = "filterByPublished";
+const _fBRS = "filterByRecordingState";
+const _fBS = "filterByState";
+const _fBSA = "filterByStageArn";
+const _fBUI = "filterByUserId";
+const _fJT = "firstJoinTime";
+const _fPA = "featuredParticipantAttribute";
+const _fi = "fingerprint";
+const _fo = "format";
+const _fr = "framerate";
+const _g = "grid";
+const _gG = "gridGap";
+const _h = "height";
+const _hC = "hlsConfiguration";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _hQ = "httpQuery";
+const _ht = "http";
+const _i = "id";
+const _iC = "ingestConfiguration";
+const _iCn = "ingestConfigurations";
+const _iI = "insecureIngest";
+const _iN = "ispName";
+const _iP = "ingestProtocol";
+const _iT = "idempotencyToken";
+const _l = "layout";
+const _mR = "maxResults";
+const _mT = "mediaTypes";
+const _n = "name";
+const _nT = "nextToken";
+const _oN = "osName";
+const _oSV = "omitStoppedVideo";
+const _oV = "osVersion";
+const _p = "participant";
+const _pB = "pipBehavior";
+const _pH = "pipHeight";
+const _pI = "participantId";
+const _pK = "publicKey";
+const _pKM = "publicKeyMaterial";
+const _pKu = "publicKeys";
+const _pO = "pipOffset";
+const _pOA = "participantOrderAttribute";
+const _pP = "pipPosition";
+const _pPA = "pipParticipantAttribute";
+const _pT = "participantToken";
+const _pTC = "participantTokenConfigurations";
+const _pTa = "participantTokens";
+const _pW = "pipWidth";
+const _pa = "participants";
+const _pi = "pip";
+const _pr = "protocol";
+const _pu = "published";
+const _r = "reason";
+const _rA = "resourceArn";
+const _rC = "recordingConfiguration";
+const _rM = "recordingMode";
+const _rP = "recordingPrefix";
+const _rPI = "remoteParticipantId";
+const _rPR = "recordParticipantReplicas";
+const _rRWS = "recordingReconnectWindowSeconds";
+const _rS = "recordingState";
+const _rSBN = "recordingS3BucketName";
+const _rSP = "recordingS3Prefix";
+const _rSe = "replicationState";
+const _rT = "replicationType";
+const _rWS = "reconnectWindowSeconds";
+const _re = "replica";
+const _rep = "replicas";
+const _rt = "rtmp";
+const _rtm = "rtmps";
+const _s = "state";
+const _sA = "stageArn";
+const _sC = "storageConfiguration";
+const _sCA = "storageConfigurationArn";
+const _sCt = "storageConfigurations";
+const _sI = "sessionId";
+const _sK = "streamKey";
+const _sS = "stageSession";
+const _sSA = "sourceStageArn";
+const _sSI = "sourceSessionId";
+const _sSt = "stageSessions";
+const _sT = "startTime";
 const _sTS = "strictTransportSecurity";
-const _sts = "strict-transport-security";
+const _sV = "sdkVersion";
+const _s_ = "s3";
+const _se = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.ivsrealtime";
+const _st = "storage";
+const _sta = "stage";
+const _stag = "stages";
+const _t = "tags";
+const _tC = "thumbnailConfiguration";
+const _tCh = "thumbnailConfigurations";
+const _tIS = "targetIntervalSeconds";
 const _tK = "tagKeys";
+const _tSDS = "targetSegmentDurationSeconds";
+const _to = "token";
+const _uI = "userId";
+const _v = "video";
+const _vAR = "videoAspectRatio";
+const _vFM = "videoFillMode";
+const _w = "whip";
+const _wi = "width";
 const _xAET = "xAmznErrorType";
 const _xCTO = "xContentTypeOptions";
 const _xFO = "xFrameOptions";
-const _xae = "x-amzn-errortype";
-const _xcto = "x-content-type-options";
-const _xfo = "x-frame-options";
+const _xaE = "x-amzn-ErrorType";
+const n0 = "com.amazonaws.ivsrealtime";
+var ParticipantTokenString = [0, n0, _PTS, 8, 0];
+var StreamKey = [0, n0, _SK, 8, 0];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_aCAO, _aCEH, _cC, _cSP, _sTS, _xCTO, _xFO, _xAET, _eM],
+    [
+        [
+            0,
+            {
+                [_hH]: _ACAO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _ACEH,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CC,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CSP,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _STS,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XCTO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XFO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xaE,
+            },
+        ],
+        0,
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var AutoParticipantRecordingConfiguration = [
+    3,
+    n0,
+    _APRC,
+    0,
+    [_sCA, _mT, _tC, _rRWS, _hC, _rPR],
+    [0, 64 | 0, () => ParticipantThumbnailConfiguration, 1, () => ParticipantRecordingHlsConfiguration, 2],
+];
+var ChannelDestinationConfiguration = [3, n0, _CDC, 0, [_cA, _eCA], [0, 0]];
+var Composition = [
+    3,
+    n0,
+    _C,
+    0,
+    [_a, _sA, _s, _l, _d, _t, _sT, _eT],
+    [0, 0, 0, () => LayoutConfiguration, () => DestinationList, 128 | 0, 5, 5],
+];
+var CompositionRecordingHlsConfiguration = [3, n0, _CRHC, 0, [_tSDS], [1]];
+var CompositionSummary = [
+    3,
+    n0,
+    _CS,
+    0,
+    [_a, _sA, _d, _s, _t, _sT, _eT],
+    [0, 0, () => DestinationSummaryList, 0, 128 | 0, 5, 5],
+];
+var CompositionThumbnailConfiguration = [3, n0, _CTC, 0, [_tIS, _st], [1, 64 | 0]];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_aCAO, _aCEH, _cC, _cSP, _sTS, _xCTO, _xFO, _xAET, _eM],
+    [
+        [
+            0,
+            {
+                [_hH]: _ACAO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _ACEH,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CC,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CSP,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _STS,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XCTO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XFO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xaE,
+            },
+        ],
+        0,
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CreateEncoderConfigurationRequest = [
+    3,
+    n0,
+    _CECR,
+    0,
+    [_n, _v, _t],
+    [0, () => Video, 128 | 0],
+];
+var CreateEncoderConfigurationResponse = [
+    3,
+    n0,
+    _CECRr,
+    0,
+    [_eC],
+    [() => EncoderConfiguration],
+];
+var CreateIngestConfigurationRequest = [
+    3,
+    n0,
+    _CICR,
+    0,
+    [_n, _sA, _uI, _at, _iP, _iI, _t],
+    [0, 0, 0, 128 | 0, 0, 2, 128 | 0],
+];
+var CreateIngestConfigurationResponse = [
+    3,
+    n0,
+    _CICRr,
+    0,
+    [_iC],
+    [[() => IngestConfiguration, 0]],
+];
+var CreateParticipantTokenRequest = [
+    3,
+    n0,
+    _CPTR,
+    0,
+    [_sA, _du, _uI, _at, _ca],
+    [0, 1, 0, 128 | 0, 64 | 0],
+];
+var CreateParticipantTokenResponse = [
+    3,
+    n0,
+    _CPTRr,
+    0,
+    [_pT],
+    [[() => ParticipantToken, 0]],
+];
+var CreateStageRequest = [
+    3,
+    n0,
+    _CSR,
+    0,
+    [_n, _pTC, _t, _aPRC],
+    [0, () => ParticipantTokenConfigurations, 128 | 0, () => AutoParticipantRecordingConfiguration],
+];
+var CreateStageResponse = [
+    3,
+    n0,
+    _CSRr,
+    0,
+    [_sta, _pTa],
+    [() => Stage, [() => ParticipantTokenList, 0]],
+];
+var CreateStorageConfigurationRequest = [
+    3,
+    n0,
+    _CSCR,
+    0,
+    [_n, _s_, _t],
+    [0, () => S3StorageConfiguration, 128 | 0],
+];
+var CreateStorageConfigurationResponse = [
+    3,
+    n0,
+    _CSCRr,
+    0,
+    [_sC],
+    [() => StorageConfiguration],
+];
+var DeleteEncoderConfigurationRequest = [3, n0, _DECR, 0, [_a], [0]];
+var DeleteEncoderConfigurationResponse = [3, n0, _DECRe, 0, [], []];
+var DeleteIngestConfigurationRequest = [3, n0, _DICR, 0, [_a, _f], [0, 2]];
+var DeleteIngestConfigurationResponse = [3, n0, _DICRe, 0, [], []];
+var DeletePublicKeyRequest = [3, n0, _DPKR, 0, [_a], [0]];
+var DeletePublicKeyResponse = [3, n0, _DPKRe, 0, [], []];
+var DeleteStageRequest = [3, n0, _DSR, 0, [_a], [0]];
+var DeleteStageResponse = [3, n0, _DSRe, 0, [], []];
+var DeleteStorageConfigurationRequest = [3, n0, _DSCR, 0, [_a], [0]];
+var DeleteStorageConfigurationResponse = [3, n0, _DSCRe, 0, [], []];
+var Destination = [
+    3,
+    n0,
+    _D,
+    0,
+    [_i, _s, _sT, _eT, _co, _de],
+    [0, 0, 5, 5, () => DestinationConfiguration, () => DestinationDetail],
+];
+var DestinationConfiguration = [
+    3,
+    n0,
+    _DC,
+    0,
+    [_n, _ch, _s_],
+    [0, () => ChannelDestinationConfiguration, () => S3DestinationConfiguration],
+];
+var DestinationDetail = [3, n0, _DD, 0, [_s_], [() => S3Detail]];
+var DestinationSummary = [3, n0, _DS, 0, [_i, _s, _sT, _eT], [0, 0, 5, 5]];
+var DisconnectParticipantRequest = [3, n0, _DPR, 0, [_sA, _pI, _r], [0, 0, 0]];
+var DisconnectParticipantResponse = [3, n0, _DPRi, 0, [], []];
+var EncoderConfiguration = [
+    3,
+    n0,
+    _EC,
+    0,
+    [_a, _n, _v, _t],
+    [0, 0, () => Video, 128 | 0],
+];
+var EncoderConfigurationSummary = [3, n0, _ECS, 0, [_a, _n, _t], [0, 0, 128 | 0]];
+var Event = [
+    3,
+    n0,
+    _E,
+    0,
+    [_n, _pI, _eTv, _rPI, _eCr, _dSA, _dSI, _re],
+    [0, 0, 5, 0, 0, 0, 0, 2],
+];
+var GetCompositionRequest = [3, n0, _GCR, 0, [_a], [0]];
+var GetCompositionResponse = [3, n0, _GCRe, 0, [_com], [() => Composition]];
+var GetEncoderConfigurationRequest = [3, n0, _GECR, 0, [_a], [0]];
+var GetEncoderConfigurationResponse = [
+    3,
+    n0,
+    _GECRe,
+    0,
+    [_eC],
+    [() => EncoderConfiguration],
+];
+var GetIngestConfigurationRequest = [3, n0, _GICR, 0, [_a], [0]];
+var GetIngestConfigurationResponse = [
+    3,
+    n0,
+    _GICRe,
+    0,
+    [_iC],
+    [[() => IngestConfiguration, 0]],
+];
+var GetParticipantRequest = [3, n0, _GPR, 0, [_sA, _sI, _pI], [0, 0, 0]];
+var GetParticipantResponse = [3, n0, _GPRe, 0, [_p], [() => Participant]];
+var GetPublicKeyRequest = [3, n0, _GPKR, 0, [_a], [0]];
+var GetPublicKeyResponse = [3, n0, _GPKRe, 0, [_pK], [() => PublicKey]];
+var GetStageRequest = [3, n0, _GSR, 0, [_a], [0]];
+var GetStageResponse = [3, n0, _GSRe, 0, [_sta], [() => Stage]];
+var GetStageSessionRequest = [3, n0, _GSSR, 0, [_sA, _sI], [0, 0]];
+var GetStageSessionResponse = [3, n0, _GSSRe, 0, [_sS], [() => StageSession]];
+var GetStorageConfigurationRequest = [3, n0, _GSCR, 0, [_a], [0]];
+var GetStorageConfigurationResponse = [
+    3,
+    n0,
+    _GSCRe,
+    0,
+    [_sC],
+    [() => StorageConfiguration],
+];
+var GridConfiguration = [
+    3,
+    n0,
+    _GC,
+    0,
+    [_fPA, _oSV, _vAR, _vFM, _gG, _pOA],
+    [0, 2, 0, 0, 1, 0],
+];
+var ImportPublicKeyRequest = [3, n0, _IPKR, 0, [_pKM, _n, _t], [0, 0, 128 | 0]];
+var ImportPublicKeyResponse = [3, n0, _IPKRm, 0, [_pK], [() => PublicKey]];
+var IngestConfiguration = [
+    3,
+    n0,
+    _IC,
+    0,
+    [_n, _a, _iP, _sK, _sA, _pI, _s, _uI, _at, _t],
+    [0, 0, 0, [() => StreamKey, 0], 0, 0, 0, 0, 128 | 0, 128 | 0],
+];
+var IngestConfigurationSummary = [
+    3,
+    n0,
+    _ICS,
+    0,
+    [_n, _a, _iP, _sA, _pI, _s, _uI],
+    [0, 0, 0, 0, 0, 0, 0],
+];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _se,
+        [_hE]: 500,
+    },
+    [_aCAO, _aCEH, _cC, _cSP, _sTS, _xCTO, _xFO, _xAET, _eM],
+    [
+        [
+            0,
+            {
+                [_hH]: _ACAO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _ACEH,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CC,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CSP,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _STS,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XCTO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XFO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xaE,
+            },
+        ],
+        0,
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var LayoutConfiguration = [
+    3,
+    n0,
+    _LC,
+    0,
+    [_g, _pi],
+    [() => GridConfiguration, () => PipConfiguration],
+];
+var ListCompositionsRequest = [3, n0, _LCR, 0, [_fBSA, _fBECA, _nT, _mR], [0, 0, 0, 1]];
+var ListCompositionsResponse = [
+    3,
+    n0,
+    _LCRi,
+    0,
+    [_comp, _nT],
+    [() => CompositionSummaryList, 0],
+];
+var ListEncoderConfigurationsRequest = [3, n0, _LECR, 0, [_nT, _mR], [0, 1]];
+var ListEncoderConfigurationsResponse = [
+    3,
+    n0,
+    _LECRi,
+    0,
+    [_eCn, _nT],
+    [() => EncoderConfigurationSummaryList, 0],
+];
+var ListIngestConfigurationsRequest = [
+    3,
+    n0,
+    _LICR,
+    0,
+    [_fBSA, _fBS, _nT, _mR],
+    [0, 0, 0, 1],
+];
+var ListIngestConfigurationsResponse = [
+    3,
+    n0,
+    _LICRi,
+    0,
+    [_iCn, _nT],
+    [() => IngestConfigurationList, 0],
+];
+var ListParticipantEventsRequest = [
+    3,
+    n0,
+    _LPER,
+    0,
+    [_sA, _sI, _pI, _nT, _mR],
+    [0, 0, 0, 0, 1],
+];
+var ListParticipantEventsResponse = [3, n0, _LPERi, 0, [_ev, _nT], [() => EventList, 0]];
+var ListParticipantReplicasRequest = [
+    3,
+    n0,
+    _LPRR,
+    0,
+    [_sSA, _pI, _nT, _mR],
+    [0, 0, 0, 1],
+];
+var ListParticipantReplicasResponse = [
+    3,
+    n0,
+    _LPRRi,
+    0,
+    [_rep, _nT],
+    [() => ParticipantReplicaList, 0],
+];
+var ListParticipantsRequest = [
+    3,
+    n0,
+    _LPR,
+    0,
+    [_sA, _sI, _fBUI, _fBP, _fBS, _nT, _mR, _fBRS],
+    [0, 0, 0, 2, 0, 0, 1, 0],
+];
+var ListParticipantsResponse = [3, n0, _LPRi, 0, [_pa, _nT], [() => ParticipantList, 0]];
+var ListPublicKeysRequest = [3, n0, _LPKR, 0, [_nT, _mR], [0, 1]];
+var ListPublicKeysResponse = [3, n0, _LPKRi, 0, [_pKu, _nT], [() => PublicKeyList, 0]];
+var ListStageSessionsRequest = [3, n0, _LSSR, 0, [_sA, _nT, _mR], [0, 0, 1]];
+var ListStageSessionsResponse = [
+    3,
+    n0,
+    _LSSRi,
+    0,
+    [_sSt, _nT],
+    [() => StageSessionList, 0],
+];
+var ListStagesRequest = [3, n0, _LSR, 0, [_nT, _mR], [0, 1]];
+var ListStagesResponse = [3, n0, _LSRi, 0, [_stag, _nT], [() => StageSummaryList, 0]];
+var ListStorageConfigurationsRequest = [3, n0, _LSCR, 0, [_nT, _mR], [0, 1]];
+var ListStorageConfigurationsResponse = [
+    3,
+    n0,
+    _LSCRi,
+    0,
+    [_sCt, _nT],
+    [() => StorageConfigurationSummaryList, 0],
+];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_rA], [[0, 1]]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_t], [128 | 0]];
+var Participant = [
+    3,
+    n0,
+    _P,
+    0,
+    [_pI, _uI, _s, _fJT, _at, _pu, _iN, _oN, _oV, _bN, _bV, _sV, _rSBN, _rSP, _rS, _pr, _rT, _rSe, _sSA, _sSI],
+    [0, 0, 0, 5, 128 | 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+];
+var ParticipantRecordingHlsConfiguration = [3, n0, _PRHC, 0, [_tSDS], [1]];
+var ParticipantReplica = [
+    3,
+    n0,
+    _PR,
+    0,
+    [_sSA, _pI, _sSI, _dSA, _dSI, _rSe],
+    [0, 0, 0, 0, 0, 0],
+];
+var ParticipantSummary = [
+    3,
+    n0,
+    _PS,
+    0,
+    [_pI, _uI, _s, _fJT, _pu, _rS, _rT, _rSe, _sSA, _sSI],
+    [0, 0, 0, 5, 2, 0, 0, 0, 0, 0],
+];
+var ParticipantThumbnailConfiguration = [
+    3,
+    n0,
+    _PTC,
+    0,
+    [_tIS, _st, _rM],
+    [1, 64 | 0, 0],
+];
+var ParticipantToken = [
+    3,
+    n0,
+    _PT,
+    0,
+    [_pI, _to, _uI, _at, _du, _ca, _eTx],
+    [0, [() => ParticipantTokenString, 0], 0, 128 | 0, 1, 64 | 0, 5],
+];
+var ParticipantTokenConfiguration = [
+    3,
+    n0,
+    _PTCa,
+    0,
+    [_du, _uI, _at, _ca],
+    [1, 0, 128 | 0, 64 | 0],
+];
+var PendingVerification = [
+    -3,
+    n0,
+    _PV,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_aCAO, _aCEH, _cC, _cSP, _sTS, _xCTO, _xFO, _xAET, _eM],
+    [
+        [
+            0,
+            {
+                [_hH]: _ACAO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _ACEH,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CC,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CSP,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _STS,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XCTO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XFO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xaE,
+            },
+        ],
+        0,
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(PendingVerification, PendingVerification$1);
+var PipConfiguration = [
+    3,
+    n0,
+    _PC,
+    0,
+    [_fPA, _oSV, _vFM, _gG, _pPA, _pB, _pO, _pP, _pW, _pH, _pOA],
+    [0, 2, 0, 1, 0, 0, 1, 0, 1, 1, 0],
+];
+var PublicKey = [3, n0, _PK, 0, [_a, _n, _pKM, _fi, _t], [0, 0, 0, 0, 128 | 0]];
+var PublicKeySummary = [3, n0, _PKS, 0, [_a, _n, _t], [0, 0, 128 | 0]];
+var RecordingConfiguration = [
+    3,
+    n0,
+    _RC,
+    0,
+    [_hC, _fo],
+    [() => CompositionRecordingHlsConfiguration, 0],
+];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_aCAO, _aCEH, _cC, _cSP, _sTS, _xCTO, _xFO, _xAET, _eM],
+    [
+        [
+            0,
+            {
+                [_hH]: _ACAO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _ACEH,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CC,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CSP,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _STS,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XCTO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XFO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xaE,
+            },
+        ],
+        0,
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var S3DestinationConfiguration = [
+    3,
+    n0,
+    _SDC,
+    0,
+    [_sCA, _eCAn, _rC, _tCh],
+    [0, 64 | 0, () => RecordingConfiguration, () => CompositionThumbnailConfigurationList],
+];
+var S3Detail = [3, n0, _SD, 0, [_rP], [0]];
+var S3StorageConfiguration = [3, n0, _SSC, 0, [_bNu], [0]];
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_aCAO, _aCEH, _cC, _cSP, _sTS, _xCTO, _xFO, _xAET, _eM],
+    [
+        [
+            0,
+            {
+                [_hH]: _ACAO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _ACEH,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CC,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CSP,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _STS,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XCTO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XFO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xaE,
+            },
+        ],
+        0,
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var Stage = [
+    3,
+    n0,
+    _S,
+    0,
+    [_a, _n, _aSI, _t, _aPRC, _en],
+    [0, 0, 0, 128 | 0, () => AutoParticipantRecordingConfiguration, () => StageEndpoints],
+];
+var StageEndpoints = [3, n0, _SE, 0, [_ev, _w, _rt, _rtm], [0, 0, 0, 0]];
+var StageSession = [3, n0, _SS, 0, [_sI, _sT, _eT], [0, 5, 5]];
+var StageSessionSummary = [3, n0, _SSS, 0, [_sI, _sT, _eT], [0, 5, 5]];
+var StageSummary = [3, n0, _SSt, 0, [_a, _n, _aSI, _t], [0, 0, 0, 128 | 0]];
+var StartCompositionRequest = [
+    3,
+    n0,
+    _SCR,
+    0,
+    [_sA, _iT, _l, _d, _t],
+    [0, [0, 4], () => LayoutConfiguration, () => DestinationConfigurationList, 128 | 0],
+];
+var StartCompositionResponse = [3, n0, _SCRt, 0, [_com], [() => Composition]];
+var StartParticipantReplicationRequest = [
+    3,
+    n0,
+    _SPRR,
+    0,
+    [_sSA, _dSA, _pI, _rWS, _at],
+    [0, 0, 0, 1, 128 | 0],
+];
+var StartParticipantReplicationResponse = [
+    3,
+    n0,
+    _SPRRt,
+    0,
+    [_aCAO, _aCEH, _cC, _cSP, _sTS, _xCTO, _xFO],
+    [
+        [
+            0,
+            {
+                [_hH]: _ACAO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _ACEH,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CC,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CSP,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _STS,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XCTO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XFO,
+            },
+        ],
+    ],
+];
+var StopCompositionRequest = [3, n0, _SCRto, 0, [_a], [0]];
+var StopCompositionResponse = [3, n0, _SCRtop, 0, [], []];
+var StopParticipantReplicationRequest = [3, n0, _SPRRto, 0, [_sSA, _dSA, _pI], [0, 0, 0]];
+var StopParticipantReplicationResponse = [
+    3,
+    n0,
+    _SPRRtop,
+    0,
+    [_aCAO, _aCEH, _cC, _cSP, _sTS, _xCTO, _xFO],
+    [
+        [
+            0,
+            {
+                [_hH]: _ACAO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _ACEH,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CC,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CSP,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _STS,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XCTO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XFO,
+            },
+        ],
+    ],
+];
+var StorageConfiguration = [
+    3,
+    n0,
+    _SC,
+    0,
+    [_a, _n, _s_, _t],
+    [0, 0, () => S3StorageConfiguration, 128 | 0],
+];
+var StorageConfigurationSummary = [
+    3,
+    n0,
+    _SCS,
+    0,
+    [_a, _n, _s_, _t],
+    [0, 0, () => S3StorageConfiguration, 128 | 0],
+];
+var TagResourceRequest = [3, n0, _TRR, 0, [_rA, _t], [[0, 1], 128 | 0]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var UntagResourceRequest = [
+    3,
+    n0,
+    _URR,
+    0,
+    [_rA, _tK],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UpdateIngestConfigurationRequest = [3, n0, _UICR, 0, [_a, _sA], [0, 0]];
+var UpdateIngestConfigurationResponse = [
+    3,
+    n0,
+    _UICRp,
+    0,
+    [_iC],
+    [[() => IngestConfiguration, 0]],
+];
+var UpdateStageRequest = [
+    3,
+    n0,
+    _USR,
+    0,
+    [_a, _n, _aPRC],
+    [0, 0, () => AutoParticipantRecordingConfiguration],
+];
+var UpdateStageResponse = [3, n0, _USRp, 0, [_sta], [() => Stage]];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_aCAO, _aCEH, _cC, _cSP, _sTS, _xCTO, _xFO, _xAET, _eM],
+    [
+        [
+            0,
+            {
+                [_hH]: _ACAO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _ACEH,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CC,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CSP,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _STS,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XCTO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XFO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xaE,
+            },
+        ],
+        0,
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var Video = [3, n0, _V, 0, [_wi, _h, _fr, _b], [1, 1, 1, 1]];
+var IVSRealTimeServiceException = [-3, _sm, "IVSRealTimeServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(IVSRealTimeServiceException, IVSRealTimeServiceException$1);
+var CompositionSummaryList = [1, n0, _CSL, 0, () => CompositionSummary];
+var CompositionThumbnailConfigurationList = [
+    1,
+    n0,
+    _CTCL,
+    0,
+    () => CompositionThumbnailConfiguration,
+];
+var DestinationConfigurationList = [1, n0, _DCL, 0, () => DestinationConfiguration];
+var DestinationList = [1, n0, _DL, 0, () => Destination];
+var DestinationSummaryList = [1, n0, _DSL, 0, () => DestinationSummary];
+var EncoderConfigurationSummaryList = [1, n0, _ECSL, 0, () => EncoderConfigurationSummary];
+var EventList = [1, n0, _EL, 0, () => Event];
+var IngestConfigurationList = [1, n0, _ICL, 0, () => IngestConfigurationSummary];
+var ParticipantList = [1, n0, _PL, 0, () => ParticipantSummary];
+var ParticipantReplicaList = [1, n0, _PRL, 0, () => ParticipantReplica];
+var ParticipantTokenConfigurations = [1, n0, _PTCar, 0, () => ParticipantTokenConfiguration];
+var ParticipantTokenList = [1, n0, _PTL, 0, [() => ParticipantToken, 0]];
+var PublicKeyList = [1, n0, _PKL, 0, () => PublicKeySummary];
+var StageSessionList = [1, n0, _SSL, 0, () => StageSessionSummary];
+var StageSummaryList = [1, n0, _SSLt, 0, () => StageSummary];
+var StorageConfigurationSummaryList = [1, n0, _SCSL, 0, () => StorageConfigurationSummary];
+var CreateEncoderConfiguration = [
+    9,
+    n0,
+    _CEC,
+    {
+        [_ht]: ["POST", "/CreateEncoderConfiguration", 200],
+    },
+    () => CreateEncoderConfigurationRequest,
+    () => CreateEncoderConfigurationResponse,
+];
+var CreateIngestConfiguration = [
+    9,
+    n0,
+    _CIC,
+    {
+        [_ht]: ["POST", "/CreateIngestConfiguration", 200],
+    },
+    () => CreateIngestConfigurationRequest,
+    () => CreateIngestConfigurationResponse,
+];
+var CreateParticipantToken = [
+    9,
+    n0,
+    _CPT,
+    {
+        [_ht]: ["POST", "/CreateParticipantToken", 200],
+    },
+    () => CreateParticipantTokenRequest,
+    () => CreateParticipantTokenResponse,
+];
+var CreateStage = [
+    9,
+    n0,
+    _CSr,
+    {
+        [_ht]: ["POST", "/CreateStage", 200],
+    },
+    () => CreateStageRequest,
+    () => CreateStageResponse,
+];
+var CreateStorageConfiguration = [
+    9,
+    n0,
+    _CSC,
+    {
+        [_ht]: ["POST", "/CreateStorageConfiguration", 200],
+    },
+    () => CreateStorageConfigurationRequest,
+    () => CreateStorageConfigurationResponse,
+];
+var DeleteEncoderConfiguration = [
+    9,
+    n0,
+    _DEC,
+    {
+        [_ht]: ["POST", "/DeleteEncoderConfiguration", 200],
+    },
+    () => DeleteEncoderConfigurationRequest,
+    () => DeleteEncoderConfigurationResponse,
+];
+var DeleteIngestConfiguration = [
+    9,
+    n0,
+    _DIC,
+    {
+        [_ht]: ["POST", "/DeleteIngestConfiguration", 200],
+    },
+    () => DeleteIngestConfigurationRequest,
+    () => DeleteIngestConfigurationResponse,
+];
+var DeletePublicKey = [
+    9,
+    n0,
+    _DPK,
+    {
+        [_ht]: ["POST", "/DeletePublicKey", 200],
+    },
+    () => DeletePublicKeyRequest,
+    () => DeletePublicKeyResponse,
+];
+var DeleteStage = [
+    9,
+    n0,
+    _DSe,
+    {
+        [_ht]: ["POST", "/DeleteStage", 200],
+    },
+    () => DeleteStageRequest,
+    () => DeleteStageResponse,
+];
+var DeleteStorageConfiguration = [
+    9,
+    n0,
+    _DSC,
+    {
+        [_ht]: ["POST", "/DeleteStorageConfiguration", 200],
+    },
+    () => DeleteStorageConfigurationRequest,
+    () => DeleteStorageConfigurationResponse,
+];
+var DisconnectParticipant = [
+    9,
+    n0,
+    _DP,
+    {
+        [_ht]: ["POST", "/DisconnectParticipant", 200],
+    },
+    () => DisconnectParticipantRequest,
+    () => DisconnectParticipantResponse,
+];
+var GetComposition = [
+    9,
+    n0,
+    _GCe,
+    {
+        [_ht]: ["POST", "/GetComposition", 200],
+    },
+    () => GetCompositionRequest,
+    () => GetCompositionResponse,
+];
+var GetEncoderConfiguration = [
+    9,
+    n0,
+    _GEC,
+    {
+        [_ht]: ["POST", "/GetEncoderConfiguration", 200],
+    },
+    () => GetEncoderConfigurationRequest,
+    () => GetEncoderConfigurationResponse,
+];
+var GetIngestConfiguration = [
+    9,
+    n0,
+    _GIC,
+    {
+        [_ht]: ["POST", "/GetIngestConfiguration", 200],
+    },
+    () => GetIngestConfigurationRequest,
+    () => GetIngestConfigurationResponse,
+];
+var GetParticipant = [
+    9,
+    n0,
+    _GP,
+    {
+        [_ht]: ["POST", "/GetParticipant", 200],
+    },
+    () => GetParticipantRequest,
+    () => GetParticipantResponse,
+];
+var GetPublicKey = [
+    9,
+    n0,
+    _GPK,
+    {
+        [_ht]: ["POST", "/GetPublicKey", 200],
+    },
+    () => GetPublicKeyRequest,
+    () => GetPublicKeyResponse,
+];
+var GetStage = [
+    9,
+    n0,
+    _GS,
+    {
+        [_ht]: ["POST", "/GetStage", 200],
+    },
+    () => GetStageRequest,
+    () => GetStageResponse,
+];
+var GetStageSession = [
+    9,
+    n0,
+    _GSS,
+    {
+        [_ht]: ["POST", "/GetStageSession", 200],
+    },
+    () => GetStageSessionRequest,
+    () => GetStageSessionResponse,
+];
+var GetStorageConfiguration = [
+    9,
+    n0,
+    _GSC,
+    {
+        [_ht]: ["POST", "/GetStorageConfiguration", 200],
+    },
+    () => GetStorageConfigurationRequest,
+    () => GetStorageConfigurationResponse,
+];
+var ImportPublicKey = [
+    9,
+    n0,
+    _IPK,
+    {
+        [_ht]: ["POST", "/ImportPublicKey", 200],
+    },
+    () => ImportPublicKeyRequest,
+    () => ImportPublicKeyResponse,
+];
+var ListCompositions = [
+    9,
+    n0,
+    _LCi,
+    {
+        [_ht]: ["POST", "/ListCompositions", 200],
+    },
+    () => ListCompositionsRequest,
+    () => ListCompositionsResponse,
+];
+var ListEncoderConfigurations = [
+    9,
+    n0,
+    _LEC,
+    {
+        [_ht]: ["POST", "/ListEncoderConfigurations", 200],
+    },
+    () => ListEncoderConfigurationsRequest,
+    () => ListEncoderConfigurationsResponse,
+];
+var ListIngestConfigurations = [
+    9,
+    n0,
+    _LIC,
+    {
+        [_ht]: ["POST", "/ListIngestConfigurations", 200],
+    },
+    () => ListIngestConfigurationsRequest,
+    () => ListIngestConfigurationsResponse,
+];
+var ListParticipantEvents = [
+    9,
+    n0,
+    _LPE,
+    {
+        [_ht]: ["POST", "/ListParticipantEvents", 200],
+    },
+    () => ListParticipantEventsRequest,
+    () => ListParticipantEventsResponse,
+];
+var ListParticipantReplicas = [
+    9,
+    n0,
+    _LPRis,
+    {
+        [_ht]: ["POST", "/ListParticipantReplicas", 200],
+    },
+    () => ListParticipantReplicasRequest,
+    () => ListParticipantReplicasResponse,
+];
+var ListParticipants = [
+    9,
+    n0,
+    _LP,
+    {
+        [_ht]: ["POST", "/ListParticipants", 200],
+    },
+    () => ListParticipantsRequest,
+    () => ListParticipantsResponse,
+];
+var ListPublicKeys = [
+    9,
+    n0,
+    _LPK,
+    {
+        [_ht]: ["POST", "/ListPublicKeys", 200],
+    },
+    () => ListPublicKeysRequest,
+    () => ListPublicKeysResponse,
+];
+var ListStages = [
+    9,
+    n0,
+    _LS,
+    {
+        [_ht]: ["POST", "/ListStages", 200],
+    },
+    () => ListStagesRequest,
+    () => ListStagesResponse,
+];
+var ListStageSessions = [
+    9,
+    n0,
+    _LSS,
+    {
+        [_ht]: ["POST", "/ListStageSessions", 200],
+    },
+    () => ListStageSessionsRequest,
+    () => ListStageSessionsResponse,
+];
+var ListStorageConfigurations = [
+    9,
+    n0,
+    _LSC,
+    {
+        [_ht]: ["POST", "/ListStorageConfigurations", 200],
+    },
+    () => ListStorageConfigurationsRequest,
+    () => ListStorageConfigurationsResponse,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_ht]: ["GET", "/tags/{resourceArn}", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var StartComposition = [
+    9,
+    n0,
+    _SCt,
+    {
+        [_ht]: ["POST", "/StartComposition", 200],
+    },
+    () => StartCompositionRequest,
+    () => StartCompositionResponse,
+];
+var StartParticipantReplication = [
+    9,
+    n0,
+    _SPR,
+    {
+        [_ht]: ["POST", "/StartParticipantReplication", 200],
+    },
+    () => StartParticipantReplicationRequest,
+    () => StartParticipantReplicationResponse,
+];
+var StopComposition = [
+    9,
+    n0,
+    _SCto,
+    {
+        [_ht]: ["POST", "/StopComposition", 200],
+    },
+    () => StopCompositionRequest,
+    () => StopCompositionResponse,
+];
+var StopParticipantReplication = [
+    9,
+    n0,
+    _SPRt,
+    {
+        [_ht]: ["POST", "/StopParticipantReplication", 200],
+    },
+    () => StopParticipantReplicationRequest,
+    () => StopParticipantReplicationResponse,
+];
+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 UpdateIngestConfiguration = [
+    9,
+    n0,
+    _UIC,
+    {
+        [_ht]: ["POST", "/UpdateIngestConfiguration", 200],
+    },
+    () => UpdateIngestConfigurationRequest,
+    () => UpdateIngestConfigurationResponse,
+];
+var UpdateStage = [
+    9,
+    n0,
+    _US,
+    {
+        [_ht]: ["POST", "/UpdateStage", 200],
+    },
+    () => UpdateStageRequest,
+    () => UpdateStageResponse,
+];
 
 class CreateEncoderConfigurationCommand 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("AmazonInteractiveVideoServiceRealTime", "CreateEncoderConfiguration", {})
     .n("IVSRealTimeClient", "CreateEncoderConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateEncoderConfigurationCommand)
-    .de(de_CreateEncoderConfigurationCommand)
+    .sc(CreateEncoderConfiguration)
     .build() {
 }
 
@@ -2019,16 +2238,11 @@ class CreateIngestConfigurationCommand 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("AmazonInteractiveVideoServiceRealTime", "CreateIngestConfiguration", {})
     .n("IVSRealTimeClient", "CreateIngestConfigurationCommand")
-    .f(void 0, CreateIngestConfigurationResponseFilterSensitiveLog)
-    .ser(se_CreateIngestConfigurationCommand)
-    .de(de_CreateIngestConfigurationCommand)
+    .sc(CreateIngestConfiguration)
     .build() {
 }
 
@@ -2036,16 +2250,11 @@ class CreateParticipantTokenCommand 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("AmazonInteractiveVideoServiceRealTime", "CreateParticipantToken", {})
     .n("IVSRealTimeClient", "CreateParticipantTokenCommand")
-    .f(void 0, CreateParticipantTokenResponseFilterSensitiveLog)
-    .ser(se_CreateParticipantTokenCommand)
-    .de(de_CreateParticipantTokenCommand)
+    .sc(CreateParticipantToken)
     .build() {
 }
 
@@ -2053,16 +2262,11 @@ class CreateStageCommand 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("AmazonInteractiveVideoServiceRealTime", "CreateStage", {})
     .n("IVSRealTimeClient", "CreateStageCommand")
-    .f(void 0, CreateStageResponseFilterSensitiveLog)
-    .ser(se_CreateStageCommand)
-    .de(de_CreateStageCommand)
+    .sc(CreateStage)
     .build() {
 }
 
@@ -2070,16 +2274,11 @@ class CreateStorageConfigurationCommand 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("AmazonInteractiveVideoServiceRealTime", "CreateStorageConfiguration", {})
     .n("IVSRealTimeClient", "CreateStorageConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateStorageConfigurationCommand)
-    .de(de_CreateStorageConfigurationCommand)
+    .sc(CreateStorageConfiguration)
     .build() {
 }
 
@@ -2087,16 +2286,11 @@ class DeleteEncoderConfigurationCommand 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("AmazonInteractiveVideoServiceRealTime", "DeleteEncoderConfiguration", {})
     .n("IVSRealTimeClient", "DeleteEncoderConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteEncoderConfigurationCommand)
-    .de(de_DeleteEncoderConfigurationCommand)
+    .sc(DeleteEncoderConfiguration)
     .build() {
 }
 
@@ -2104,16 +2298,11 @@ class DeleteIngestConfigurationCommand 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("AmazonInteractiveVideoServiceRealTime", "DeleteIngestConfiguration", {})
     .n("IVSRealTimeClient", "DeleteIngestConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteIngestConfigurationCommand)
-    .de(de_DeleteIngestConfigurationCommand)
+    .sc(DeleteIngestConfiguration)
     .build() {
 }
 
@@ -2121,16 +2310,11 @@ class DeletePublicKeyCommand 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("AmazonInteractiveVideoServiceRealTime", "DeletePublicKey", {})
     .n("IVSRealTimeClient", "DeletePublicKeyCommand")
-    .f(void 0, void 0)
-    .ser(se_DeletePublicKeyCommand)
-    .de(de_DeletePublicKeyCommand)
+    .sc(DeletePublicKey)
     .build() {
 }
 
@@ -2138,16 +2322,11 @@ class DeleteStageCommand 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("AmazonInteractiveVideoServiceRealTime", "DeleteStage", {})
     .n("IVSRealTimeClient", "DeleteStageCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteStageCommand)
-    .de(de_DeleteStageCommand)
+    .sc(DeleteStage)
     .build() {
 }
 
@@ -2155,16 +2334,11 @@ class DeleteStorageConfigurationCommand 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("AmazonInteractiveVideoServiceRealTime", "DeleteStorageConfiguration", {})
     .n("IVSRealTimeClient", "DeleteStorageConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteStorageConfigurationCommand)
-    .de(de_DeleteStorageConfigurationCommand)
+    .sc(DeleteStorageConfiguration)
     .build() {
 }
 
@@ -2172,16 +2346,11 @@ class DisconnectParticipantCommand 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("AmazonInteractiveVideoServiceRealTime", "DisconnectParticipant", {})
     .n("IVSRealTimeClient", "DisconnectParticipantCommand")
-    .f(void 0, void 0)
-    .ser(se_DisconnectParticipantCommand)
-    .de(de_DisconnectParticipantCommand)
+    .sc(DisconnectParticipant)
     .build() {
 }
 
@@ -2189,16 +2358,11 @@ class GetCompositionCommand 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("AmazonInteractiveVideoServiceRealTime", "GetComposition", {})
     .n("IVSRealTimeClient", "GetCompositionCommand")
-    .f(void 0, void 0)
-    .ser(se_GetCompositionCommand)
-    .de(de_GetCompositionCommand)
+    .sc(GetComposition)
     .build() {
 }
 
@@ -2206,16 +2370,11 @@ class GetEncoderConfigurationCommand 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("AmazonInteractiveVideoServiceRealTime", "GetEncoderConfiguration", {})
     .n("IVSRealTimeClient", "GetEncoderConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_GetEncoderConfigurationCommand)
-    .de(de_GetEncoderConfigurationCommand)
+    .sc(GetEncoderConfiguration)
     .build() {
 }
 
@@ -2223,16 +2382,11 @@ class GetIngestConfigurationCommand 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("AmazonInteractiveVideoServiceRealTime", "GetIngestConfiguration", {})
     .n("IVSRealTimeClient", "GetIngestConfigurationCommand")
-    .f(void 0, GetIngestConfigurationResponseFilterSensitiveLog)
-    .ser(se_GetIngestConfigurationCommand)
-    .de(de_GetIngestConfigurationCommand)
+    .sc(GetIngestConfiguration)
     .build() {
 }
 
@@ -2240,16 +2394,11 @@ class GetParticipantCommand 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("AmazonInteractiveVideoServiceRealTime", "GetParticipant", {})
     .n("IVSRealTimeClient", "GetParticipantCommand")
-    .f(void 0, void 0)
-    .ser(se_GetParticipantCommand)
-    .de(de_GetParticipantCommand)
+    .sc(GetParticipant)
     .build() {
 }
 
@@ -2257,16 +2406,11 @@ class GetPublicKeyCommand 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("AmazonInteractiveVideoServiceRealTime", "GetPublicKey", {})
     .n("IVSRealTimeClient", "GetPublicKeyCommand")
-    .f(void 0, void 0)
-    .ser(se_GetPublicKeyCommand)
-    .de(de_GetPublicKeyCommand)
+    .sc(GetPublicKey)
     .build() {
 }
 
@@ -2274,16 +2418,11 @@ class GetStageCommand 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("AmazonInteractiveVideoServiceRealTime", "GetStage", {})
     .n("IVSRealTimeClient", "GetStageCommand")
-    .f(void 0, void 0)
-    .ser(se_GetStageCommand)
-    .de(de_GetStageCommand)
+    .sc(GetStage)
     .build() {
 }
 
@@ -2291,16 +2430,11 @@ class GetStageSessionCommand 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("AmazonInteractiveVideoServiceRealTime", "GetStageSession", {})
     .n("IVSRealTimeClient", "GetStageSessionCommand")
-    .f(void 0, void 0)
-    .ser(se_GetStageSessionCommand)
-    .de(de_GetStageSessionCommand)
+    .sc(GetStageSession)
     .build() {
 }
 
@@ -2308,16 +2442,11 @@ class GetStorageConfigurationCommand 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("AmazonInteractiveVideoServiceRealTime", "GetStorageConfiguration", {})
     .n("IVSRealTimeClient", "GetStorageConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_GetStorageConfigurationCommand)
-    .de(de_GetStorageConfigurationCommand)
+    .sc(GetStorageConfiguration)
     .build() {
 }
 
@@ -2325,16 +2454,11 @@ class ImportPublicKeyCommand 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("AmazonInteractiveVideoServiceRealTime", "ImportPublicKey", {})
     .n("IVSRealTimeClient", "ImportPublicKeyCommand")
-    .f(void 0, void 0)
-    .ser(se_ImportPublicKeyCommand)
-    .de(de_ImportPublicKeyCommand)
+    .sc(ImportPublicKey)
     .build() {
 }
 
@@ -2342,16 +2466,11 @@ class ListCompositionsCommand 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("AmazonInteractiveVideoServiceRealTime", "ListCompositions", {})
     .n("IVSRealTimeClient", "ListCompositionsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListCompositionsCommand)
-    .de(de_ListCompositionsCommand)
+    .sc(ListCompositions)
     .build() {
 }
 
@@ -2359,16 +2478,11 @@ class ListEncoderConfigurationsCommand 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("AmazonInteractiveVideoServiceRealTime", "ListEncoderConfigurations", {})
     .n("IVSRealTimeClient", "ListEncoderConfigurationsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListEncoderConfigurationsCommand)
-    .de(de_ListEncoderConfigurationsCommand)
+    .sc(ListEncoderConfigurations)
     .build() {
 }
 
@@ -2376,16 +2490,11 @@ class ListIngestConfigurationsCommand 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("AmazonInteractiveVideoServiceRealTime", "ListIngestConfigurations", {})
     .n("IVSRealTimeClient", "ListIngestConfigurationsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListIngestConfigurationsCommand)
-    .de(de_ListIngestConfigurationsCommand)
+    .sc(ListIngestConfigurations)
     .build() {
 }
 
@@ -2393,16 +2502,11 @@ class ListParticipantEventsCommand 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("AmazonInteractiveVideoServiceRealTime", "ListParticipantEvents", {})
     .n("IVSRealTimeClient", "ListParticipantEventsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListParticipantEventsCommand)
-    .de(de_ListParticipantEventsCommand)
+    .sc(ListParticipantEvents)
     .build() {
 }
 
@@ -2410,16 +2514,11 @@ class ListParticipantReplicasCommand 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("AmazonInteractiveVideoServiceRealTime", "ListParticipantReplicas", {})
     .n("IVSRealTimeClient", "ListParticipantReplicasCommand")
-    .f(void 0, void 0)
-    .ser(se_ListParticipantReplicasCommand)
-    .de(de_ListParticipantReplicasCommand)
+    .sc(ListParticipantReplicas)
     .build() {
 }
 
@@ -2427,16 +2526,11 @@ class ListParticipantsCommand 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("AmazonInteractiveVideoServiceRealTime", "ListParticipants", {})
     .n("IVSRealTimeClient", "ListParticipantsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListParticipantsCommand)
-    .de(de_ListParticipantsCommand)
+    .sc(ListParticipants)
     .build() {
 }
 
@@ -2444,16 +2538,11 @@ class ListPublicKeysCommand 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("AmazonInteractiveVideoServiceRealTime", "ListPublicKeys", {})
     .n("IVSRealTimeClient", "ListPublicKeysCommand")
-    .f(void 0, void 0)
-    .ser(se_ListPublicKeysCommand)
-    .de(de_ListPublicKeysCommand)
+    .sc(ListPublicKeys)
     .build() {
 }
 
@@ -2461,16 +2550,11 @@ class ListStagesCommand 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("AmazonInteractiveVideoServiceRealTime", "ListStages", {})
     .n("IVSRealTimeClient", "ListStagesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListStagesCommand)
-    .de(de_ListStagesCommand)
+    .sc(ListStages)
     .build() {
 }
 
@@ -2478,16 +2562,11 @@ class ListStageSessionsCommand 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("AmazonInteractiveVideoServiceRealTime", "ListStageSessions", {})
     .n("IVSRealTimeClient", "ListStageSessionsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListStageSessionsCommand)
-    .de(de_ListStageSessionsCommand)
+    .sc(ListStageSessions)
     .build() {
 }
 
@@ -2495,16 +2574,11 @@ class ListStorageConfigurationsCommand 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("AmazonInteractiveVideoServiceRealTime", "ListStorageConfigurations", {})
     .n("IVSRealTimeClient", "ListStorageConfigurationsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListStorageConfigurationsCommand)
-    .de(de_ListStorageConfigurationsCommand)
+    .sc(ListStorageConfigurations)
     .build() {
 }
 
@@ -2512,16 +2586,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("AmazonInteractiveVideoServiceRealTime", "ListTagsForResource", {})
     .n("IVSRealTimeClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -2529,16 +2598,11 @@ class StartCompositionCommand 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("AmazonInteractiveVideoServiceRealTime", "StartComposition", {})
     .n("IVSRealTimeClient", "StartCompositionCommand")
-    .f(void 0, void 0)
-    .ser(se_StartCompositionCommand)
-    .de(de_StartCompositionCommand)
+    .sc(StartComposition)
     .build() {
 }
 
@@ -2546,16 +2610,11 @@ class StartParticipantReplicationCommand 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("AmazonInteractiveVideoServiceRealTime", "StartParticipantReplication", {})
     .n("IVSRealTimeClient", "StartParticipantReplicationCommand")
-    .f(void 0, void 0)
-    .ser(se_StartParticipantReplicationCommand)
-    .de(de_StartParticipantReplicationCommand)
+    .sc(StartParticipantReplication)
     .build() {
 }
 
@@ -2563,16 +2622,11 @@ class StopCompositionCommand 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("AmazonInteractiveVideoServiceRealTime", "StopComposition", {})
     .n("IVSRealTimeClient", "StopCompositionCommand")
-    .f(void 0, void 0)
-    .ser(se_StopCompositionCommand)
-    .de(de_StopCompositionCommand)
+    .sc(StopComposition)
     .build() {
 }
 
@@ -2580,16 +2634,11 @@ class StopParticipantReplicationCommand 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("AmazonInteractiveVideoServiceRealTime", "StopParticipantReplication", {})
     .n("IVSRealTimeClient", "StopParticipantReplicationCommand")
-    .f(void 0, void 0)
-    .ser(se_StopParticipantReplicationCommand)
-    .de(de_StopParticipantReplicationCommand)
+    .sc(StopParticipantReplication)
     .build() {
 }
 
@@ -2597,16 +2646,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("AmazonInteractiveVideoServiceRealTime", "TagResource", {})
     .n("IVSRealTimeClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -2614,16 +2658,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("AmazonInteractiveVideoServiceRealTime", "UntagResource", {})
     .n("IVSRealTimeClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -2631,16 +2670,11 @@ class UpdateIngestConfigurationCommand 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("AmazonInteractiveVideoServiceRealTime", "UpdateIngestConfiguration", {})
     .n("IVSRealTimeClient", "UpdateIngestConfigurationCommand")
-    .f(void 0, UpdateIngestConfigurationResponseFilterSensitiveLog)
-    .ser(se_UpdateIngestConfigurationCommand)
-    .de(de_UpdateIngestConfigurationCommand)
+    .sc(UpdateIngestConfiguration)
     .build() {
 }
 
@@ -2648,16 +2682,11 @@ class UpdateStageCommand 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("AmazonInteractiveVideoServiceRealTime", "UpdateStage", {})
     .n("IVSRealTimeClient", "UpdateStageCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateStageCommand)
-    .de(de_UpdateStageCommand)
+    .sc(UpdateStage)
     .build() {
 }
 
@@ -2734,16 +2763,13 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.CompositionState = CompositionState;
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.CreateEncoderConfigurationCommand = CreateEncoderConfigurationCommand;
 exports.CreateIngestConfigurationCommand = CreateIngestConfigurationCommand;
-exports.CreateIngestConfigurationResponseFilterSensitiveLog = CreateIngestConfigurationResponseFilterSensitiveLog;
 exports.CreateParticipantTokenCommand = CreateParticipantTokenCommand;
-exports.CreateParticipantTokenResponseFilterSensitiveLog = CreateParticipantTokenResponseFilterSensitiveLog;
 exports.CreateStageCommand = CreateStageCommand;
-exports.CreateStageResponseFilterSensitiveLog = CreateStageResponseFilterSensitiveLog;
 exports.CreateStorageConfigurationCommand = CreateStorageConfigurationCommand;
 exports.DeleteEncoderConfigurationCommand = DeleteEncoderConfigurationCommand;
 exports.DeleteIngestConfigurationCommand = DeleteIngestConfigurationCommand;
@@ -2757,7 +2783,6 @@ exports.EventName = EventName;
 exports.GetCompositionCommand = GetCompositionCommand;
 exports.GetEncoderConfigurationCommand = GetEncoderConfigurationCommand;
 exports.GetIngestConfigurationCommand = GetIngestConfigurationCommand;
-exports.GetIngestConfigurationResponseFilterSensitiveLog = GetIngestConfigurationResponseFilterSensitiveLog;
 exports.GetParticipantCommand = GetParticipantCommand;
 exports.GetPublicKeyCommand = GetPublicKeyCommand;
 exports.GetStageCommand = GetStageCommand;
@@ -2765,12 +2790,11 @@ exports.GetStageSessionCommand = GetStageSessionCommand;
 exports.GetStorageConfigurationCommand = GetStorageConfigurationCommand;
 exports.IVSRealTime = IVSRealTime;
 exports.IVSRealTimeClient = IVSRealTimeClient;
-exports.IVSRealTimeServiceException = IVSRealTimeServiceException;
+exports.IVSRealTimeServiceException = IVSRealTimeServiceException$1;
 exports.ImportPublicKeyCommand = ImportPublicKeyCommand;
-exports.IngestConfigurationFilterSensitiveLog = IngestConfigurationFilterSensitiveLog;
 exports.IngestConfigurationState = IngestConfigurationState;
 exports.IngestProtocol = IngestProtocol;
-exports.InternalServerException = InternalServerException;
+exports.InternalServerException = InternalServerException$1;
 exports.ListCompositionsCommand = ListCompositionsCommand;
 exports.ListEncoderConfigurationsCommand = ListEncoderConfigurationsCommand;
 exports.ListIngestConfigurationsCommand = ListIngestConfigurationsCommand;
@@ -2788,15 +2812,14 @@ exports.ParticipantRecordingMediaType = ParticipantRecordingMediaType;
 exports.ParticipantRecordingState = ParticipantRecordingState;
 exports.ParticipantState = ParticipantState;
 exports.ParticipantTokenCapability = ParticipantTokenCapability;
-exports.ParticipantTokenFilterSensitiveLog = ParticipantTokenFilterSensitiveLog;
-exports.PendingVerification = PendingVerification;
+exports.PendingVerification = PendingVerification$1;
 exports.PipBehavior = PipBehavior;
 exports.PipPosition = PipPosition;
 exports.RecordingConfigurationFormat = RecordingConfigurationFormat;
 exports.ReplicationState = ReplicationState;
 exports.ReplicationType = ReplicationType;
-exports.ResourceNotFoundException = ResourceNotFoundException;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.StartCompositionCommand = StartCompositionCommand;
 exports.StartParticipantReplicationCommand = StartParticipantReplicationCommand;
 exports.StopCompositionCommand = StopCompositionCommand;
@@ -2806,9 +2829,8 @@ exports.ThumbnailRecordingMode = ThumbnailRecordingMode;
 exports.ThumbnailStorageType = ThumbnailStorageType;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateIngestConfigurationCommand = UpdateIngestConfigurationCommand;
-exports.UpdateIngestConfigurationResponseFilterSensitiveLog = UpdateIngestConfigurationResponseFilterSensitiveLog;
 exports.UpdateStageCommand = UpdateStageCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.VideoAspectRatio = VideoAspectRatio;
 exports.VideoFillMode = VideoFillMode;
 exports.paginateListCompositions = paginateListCompositions;