@aws-sdk/client-chime 3.183.0 → 3.185.0

package/dist-es/commands/GetAppInstanceRetentionSettingsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetAppInstanceRetentionSettingsRequestFilterSensitiveLog, GetAppInstanceRetentionSettingsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetAppInstanceRetentionSettingsCommand, serializeAws_restJson1GetAppInstanceRetentionSettingsCommand, } from "../protocols/Aws_restJson1";
-export class GetAppInstanceRetentionSettingsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetAppInstanceRetentionSettingsCommand = (function (_super) {
+    __extends(GetAppInstanceRetentionSettingsCommand, _super);
+    function GetAppInstanceRetentionSettingsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetAppInstanceRetentionSettingsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ChimeClient";
-        const commandName = "GetAppInstanceRetentionSettingsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetAppInstanceRetentionSettingsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetAppInstanceRetentionSettingsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetAppInstanceRetentionSettingsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetAppInstanceRetentionSettingsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetAppInstanceRetentionSettingsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetAppInstanceRetentionSettingsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetAppInstanceRetentionSettingsCommand(output, context);
-    }
-}
+    };
+    return GetAppInstanceRetentionSettingsCommand;
+}($Command));
+export { GetAppInstanceRetentionSettingsCommand };

package/dist-es/commands/GetAppInstanceStreamingConfigurationsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetAppInstanceStreamingConfigurationsRequestFilterSensitiveLog, GetAppInstanceStreamingConfigurationsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetAppInstanceStreamingConfigurationsCommand, serializeAws_restJson1GetAppInstanceStreamingConfigurationsCommand, } from "../protocols/Aws_restJson1";
-export class GetAppInstanceStreamingConfigurationsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetAppInstanceStreamingConfigurationsCommand = (function (_super) {
+    __extends(GetAppInstanceStreamingConfigurationsCommand, _super);
+    function GetAppInstanceStreamingConfigurationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetAppInstanceStreamingConfigurationsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ChimeClient";
-        const commandName = "GetAppInstanceStreamingConfigurationsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetAppInstanceStreamingConfigurationsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetAppInstanceStreamingConfigurationsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetAppInstanceStreamingConfigurationsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetAppInstanceStreamingConfigurationsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetAppInstanceStreamingConfigurationsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetAppInstanceStreamingConfigurationsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetAppInstanceStreamingConfigurationsCommand(output, context);
-    }
-}
+    };
+    return GetAppInstanceStreamingConfigurationsCommand;
+}($Command));
+export { GetAppInstanceStreamingConfigurationsCommand };

package/dist-es/commands/GetAttendeeCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetAttendeeRequestFilterSensitiveLog, GetAttendeeResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetAttendeeCommand, serializeAws_restJson1GetAttendeeCommand, } from "../protocols/Aws_restJson1";
-export class GetAttendeeCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetAttendeeCommand = (function (_super) {
+    __extends(GetAttendeeCommand, _super);
+    function GetAttendeeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetAttendeeCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ChimeClient";
-        const commandName = "GetAttendeeCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetAttendeeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetAttendeeRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetAttendeeResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetAttendeeCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetAttendeeCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetAttendeeCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetAttendeeCommand(output, context);
-    }
-}
+    };
+    return GetAttendeeCommand;
+}($Command));
+export { GetAttendeeCommand };

package/dist-es/commands/GetBotCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetBotRequestFilterSensitiveLog, GetBotResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetBotCommand, serializeAws_restJson1GetBotCommand } from "../protocols/Aws_restJson1";
-export class GetBotCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetBotCommand = (function (_super) {
+    __extends(GetBotCommand, _super);
+    function GetBotCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetBotCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ChimeClient";
-        const commandName = "GetBotCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetBotCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetBotRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetBotResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetBotCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetBotCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetBotCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetBotCommand(output, context);
-    }
-}
+    };
+    return GetBotCommand;
+}($Command));
+export { GetBotCommand };

package/dist-es/commands/GetChannelMessageCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetChannelMessageRequestFilterSensitiveLog, GetChannelMessageResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetChannelMessageCommand, serializeAws_restJson1GetChannelMessageCommand, } from "../protocols/Aws_restJson1";
-export class GetChannelMessageCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetChannelMessageCommand = (function (_super) {
+    __extends(GetChannelMessageCommand, _super);
+    function GetChannelMessageCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetChannelMessageCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ChimeClient";
-        const commandName = "GetChannelMessageCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetChannelMessageCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetChannelMessageRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetChannelMessageResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetChannelMessageCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetChannelMessageCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetChannelMessageCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetChannelMessageCommand(output, context);
-    }
-}
+    };
+    return GetChannelMessageCommand;
+}($Command));
+export { GetChannelMessageCommand };

package/dist-es/commands/GetEventsConfigurationCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetEventsConfigurationRequestFilterSensitiveLog, GetEventsConfigurationResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetEventsConfigurationCommand, serializeAws_restJson1GetEventsConfigurationCommand, } from "../protocols/Aws_restJson1";
-export class GetEventsConfigurationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetEventsConfigurationCommand = (function (_super) {
+    __extends(GetEventsConfigurationCommand, _super);
+    function GetEventsConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetEventsConfigurationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ChimeClient";
-        const commandName = "GetEventsConfigurationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetEventsConfigurationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetEventsConfigurationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetEventsConfigurationResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetEventsConfigurationCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetEventsConfigurationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetEventsConfigurationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetEventsConfigurationCommand(output, context);
-    }
-}
+    };
+    return GetEventsConfigurationCommand;
+}($Command));
+export { GetEventsConfigurationCommand };

package/dist-es/commands/GetGlobalSettingsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetGlobalSettingsResponseFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_restJson1GetGlobalSettingsCommand, serializeAws_restJson1GetGlobalSettingsCommand, } from "../protocols/Aws_restJson1";
-export class GetGlobalSettingsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetGlobalSettingsCommand = (function (_super) {
+    __extends(GetGlobalSettingsCommand, _super);
+    function GetGlobalSettingsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetGlobalSettingsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ChimeClient";
-        const commandName = "GetGlobalSettingsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (input) => input,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetGlobalSettingsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: function (input) { return input; },
             outputFilterSensitiveLog: GetGlobalSettingsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetGlobalSettingsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetGlobalSettingsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetGlobalSettingsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetGlobalSettingsCommand(output, context);
-    }
-}
+    };
+    return GetGlobalSettingsCommand;
+}($Command));
+export { GetGlobalSettingsCommand };

package/dist-es/commands/GetMediaCapturePipelineCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetMediaCapturePipelineRequestFilterSensitiveLog, GetMediaCapturePipelineResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetMediaCapturePipelineCommand, serializeAws_restJson1GetMediaCapturePipelineCommand, } from "../protocols/Aws_restJson1";
-export class GetMediaCapturePipelineCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetMediaCapturePipelineCommand = (function (_super) {
+    __extends(GetMediaCapturePipelineCommand, _super);
+    function GetMediaCapturePipelineCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetMediaCapturePipelineCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ChimeClient";
-        const commandName = "GetMediaCapturePipelineCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetMediaCapturePipelineCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetMediaCapturePipelineRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetMediaCapturePipelineResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetMediaCapturePipelineCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetMediaCapturePipelineCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetMediaCapturePipelineCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetMediaCapturePipelineCommand(output, context);
-    }
-}
+    };
+    return GetMediaCapturePipelineCommand;
+}($Command));
+export { GetMediaCapturePipelineCommand };

package/dist-es/commands/GetMeetingCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetMeetingRequestFilterSensitiveLog, GetMeetingResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetMeetingCommand, serializeAws_restJson1GetMeetingCommand, } from "../protocols/Aws_restJson1";
-export class GetMeetingCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetMeetingCommand = (function (_super) {
+    __extends(GetMeetingCommand, _super);
+    function GetMeetingCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetMeetingCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ChimeClient";
-        const commandName = "GetMeetingCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetMeetingCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetMeetingRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetMeetingResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetMeetingCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetMeetingCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetMeetingCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetMeetingCommand(output, context);
-    }
-}
+    };
+    return GetMeetingCommand;
+}($Command));
+export { GetMeetingCommand };

package/dist-es/commands/GetMessagingSessionEndpointCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetMessagingSessionEndpointRequestFilterSensitiveLog, GetMessagingSessionEndpointResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetMessagingSessionEndpointCommand, serializeAws_restJson1GetMessagingSessionEndpointCommand, } from "../protocols/Aws_restJson1";
-export class GetMessagingSessionEndpointCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetMessagingSessionEndpointCommand = (function (_super) {
+    __extends(GetMessagingSessionEndpointCommand, _super);
+    function GetMessagingSessionEndpointCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetMessagingSessionEndpointCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ChimeClient";
-        const commandName = "GetMessagingSessionEndpointCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetMessagingSessionEndpointCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetMessagingSessionEndpointRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetMessagingSessionEndpointResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetMessagingSessionEndpointCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetMessagingSessionEndpointCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetMessagingSessionEndpointCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetMessagingSessionEndpointCommand(output, context);
-    }
-}
+    };
+    return GetMessagingSessionEndpointCommand;
+}($Command));
+export { GetMessagingSessionEndpointCommand };