@aws-sdk/client-chime 3.183.0 → 3.185.0

package/dist-es/commands/GetUserSettingsCommand.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 { GetUserSettingsRequestFilterSensitiveLog, GetUserSettingsResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1GetUserSettingsCommand, serializeAws_restJson1GetUserSettingsCommand, } from "../protocols/Aws_restJson1";
-export class GetUserSettingsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetUserSettingsCommand = (function (_super) {
+    __extends(GetUserSettingsCommand, _super);
+    function GetUserSettingsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetUserSettingsCommand.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 = "GetUserSettingsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetUserSettingsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetUserSettingsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetUserSettingsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetUserSettingsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetUserSettingsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetUserSettingsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetUserSettingsCommand(output, context);
-    }
-}
+    };
+    return GetUserSettingsCommand;
+}($Command));
+export { GetUserSettingsCommand };

package/dist-es/commands/GetVoiceConnectorCommand.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 { GetVoiceConnectorRequestFilterSensitiveLog, GetVoiceConnectorResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1GetVoiceConnectorCommand, serializeAws_restJson1GetVoiceConnectorCommand, } from "../protocols/Aws_restJson1";
-export class GetVoiceConnectorCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetVoiceConnectorCommand = (function (_super) {
+    __extends(GetVoiceConnectorCommand, _super);
+    function GetVoiceConnectorCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetVoiceConnectorCommand.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 = "GetVoiceConnectorCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetVoiceConnectorCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetVoiceConnectorRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetVoiceConnectorResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetVoiceConnectorCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetVoiceConnectorCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetVoiceConnectorCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetVoiceConnectorCommand(output, context);
-    }
-}
+    };
+    return GetVoiceConnectorCommand;
+}($Command));
+export { GetVoiceConnectorCommand };

package/dist-es/commands/GetVoiceConnectorEmergencyCallingConfigurationCommand.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 { GetVoiceConnectorEmergencyCallingConfigurationRequestFilterSensitiveLog, GetVoiceConnectorEmergencyCallingConfigurationResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1GetVoiceConnectorEmergencyCallingConfigurationCommand, serializeAws_restJson1GetVoiceConnectorEmergencyCallingConfigurationCommand, } from "../protocols/Aws_restJson1";
-export class GetVoiceConnectorEmergencyCallingConfigurationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetVoiceConnectorEmergencyCallingConfigurationCommand = (function (_super) {
+    __extends(GetVoiceConnectorEmergencyCallingConfigurationCommand, _super);
+    function GetVoiceConnectorEmergencyCallingConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetVoiceConnectorEmergencyCallingConfigurationCommand.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 = "GetVoiceConnectorEmergencyCallingConfigurationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetVoiceConnectorEmergencyCallingConfigurationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetVoiceConnectorEmergencyCallingConfigurationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetVoiceConnectorEmergencyCallingConfigurationResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetVoiceConnectorEmergencyCallingConfigurationCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetVoiceConnectorEmergencyCallingConfigurationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetVoiceConnectorEmergencyCallingConfigurationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetVoiceConnectorEmergencyCallingConfigurationCommand(output, context);
-    }
-}
+    };
+    return GetVoiceConnectorEmergencyCallingConfigurationCommand;
+}($Command));
+export { GetVoiceConnectorEmergencyCallingConfigurationCommand };

package/dist-es/commands/GetVoiceConnectorGroupCommand.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 { GetVoiceConnectorGroupRequestFilterSensitiveLog, GetVoiceConnectorGroupResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1GetVoiceConnectorGroupCommand, serializeAws_restJson1GetVoiceConnectorGroupCommand, } from "../protocols/Aws_restJson1";
-export class GetVoiceConnectorGroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetVoiceConnectorGroupCommand = (function (_super) {
+    __extends(GetVoiceConnectorGroupCommand, _super);
+    function GetVoiceConnectorGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetVoiceConnectorGroupCommand.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 = "GetVoiceConnectorGroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetVoiceConnectorGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetVoiceConnectorGroupRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetVoiceConnectorGroupResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetVoiceConnectorGroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetVoiceConnectorGroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetVoiceConnectorGroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetVoiceConnectorGroupCommand(output, context);
-    }
-}
+    };
+    return GetVoiceConnectorGroupCommand;
+}($Command));
+export { GetVoiceConnectorGroupCommand };

package/dist-es/commands/GetVoiceConnectorLoggingConfigurationCommand.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 { GetVoiceConnectorLoggingConfigurationRequestFilterSensitiveLog, GetVoiceConnectorLoggingConfigurationResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1GetVoiceConnectorLoggingConfigurationCommand, serializeAws_restJson1GetVoiceConnectorLoggingConfigurationCommand, } from "../protocols/Aws_restJson1";
-export class GetVoiceConnectorLoggingConfigurationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetVoiceConnectorLoggingConfigurationCommand = (function (_super) {
+    __extends(GetVoiceConnectorLoggingConfigurationCommand, _super);
+    function GetVoiceConnectorLoggingConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetVoiceConnectorLoggingConfigurationCommand.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 = "GetVoiceConnectorLoggingConfigurationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetVoiceConnectorLoggingConfigurationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetVoiceConnectorLoggingConfigurationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetVoiceConnectorLoggingConfigurationResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetVoiceConnectorLoggingConfigurationCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetVoiceConnectorLoggingConfigurationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetVoiceConnectorLoggingConfigurationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetVoiceConnectorLoggingConfigurationCommand(output, context);
-    }
-}
+    };
+    return GetVoiceConnectorLoggingConfigurationCommand;
+}($Command));
+export { GetVoiceConnectorLoggingConfigurationCommand };

package/dist-es/commands/GetVoiceConnectorOriginationCommand.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 { GetVoiceConnectorOriginationRequestFilterSensitiveLog, GetVoiceConnectorOriginationResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1GetVoiceConnectorOriginationCommand, serializeAws_restJson1GetVoiceConnectorOriginationCommand, } from "../protocols/Aws_restJson1";
-export class GetVoiceConnectorOriginationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetVoiceConnectorOriginationCommand = (function (_super) {
+    __extends(GetVoiceConnectorOriginationCommand, _super);
+    function GetVoiceConnectorOriginationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetVoiceConnectorOriginationCommand.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 = "GetVoiceConnectorOriginationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetVoiceConnectorOriginationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetVoiceConnectorOriginationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetVoiceConnectorOriginationResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetVoiceConnectorOriginationCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetVoiceConnectorOriginationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetVoiceConnectorOriginationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetVoiceConnectorOriginationCommand(output, context);
-    }
-}
+    };
+    return GetVoiceConnectorOriginationCommand;
+}($Command));
+export { GetVoiceConnectorOriginationCommand };

package/dist-es/commands/GetVoiceConnectorProxyCommand.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 { GetVoiceConnectorProxyRequestFilterSensitiveLog, GetVoiceConnectorProxyResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1GetVoiceConnectorProxyCommand, serializeAws_restJson1GetVoiceConnectorProxyCommand, } from "../protocols/Aws_restJson1";
-export class GetVoiceConnectorProxyCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetVoiceConnectorProxyCommand = (function (_super) {
+    __extends(GetVoiceConnectorProxyCommand, _super);
+    function GetVoiceConnectorProxyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetVoiceConnectorProxyCommand.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 = "GetVoiceConnectorProxyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetVoiceConnectorProxyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetVoiceConnectorProxyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetVoiceConnectorProxyResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetVoiceConnectorProxyCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetVoiceConnectorProxyCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetVoiceConnectorProxyCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetVoiceConnectorProxyCommand(output, context);
-    }
-}
+    };
+    return GetVoiceConnectorProxyCommand;
+}($Command));
+export { GetVoiceConnectorProxyCommand };

package/dist-es/commands/GetVoiceConnectorStreamingConfigurationCommand.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 { GetVoiceConnectorStreamingConfigurationRequestFilterSensitiveLog, GetVoiceConnectorStreamingConfigurationResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1GetVoiceConnectorStreamingConfigurationCommand, serializeAws_restJson1GetVoiceConnectorStreamingConfigurationCommand, } from "../protocols/Aws_restJson1";
-export class GetVoiceConnectorStreamingConfigurationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetVoiceConnectorStreamingConfigurationCommand = (function (_super) {
+    __extends(GetVoiceConnectorStreamingConfigurationCommand, _super);
+    function GetVoiceConnectorStreamingConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetVoiceConnectorStreamingConfigurationCommand.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 = "GetVoiceConnectorStreamingConfigurationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetVoiceConnectorStreamingConfigurationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetVoiceConnectorStreamingConfigurationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetVoiceConnectorStreamingConfigurationResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetVoiceConnectorStreamingConfigurationCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetVoiceConnectorStreamingConfigurationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetVoiceConnectorStreamingConfigurationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetVoiceConnectorStreamingConfigurationCommand(output, context);
-    }
-}
+    };
+    return GetVoiceConnectorStreamingConfigurationCommand;
+}($Command));
+export { GetVoiceConnectorStreamingConfigurationCommand };

package/dist-es/commands/GetVoiceConnectorTerminationCommand.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 { GetVoiceConnectorTerminationRequestFilterSensitiveLog, GetVoiceConnectorTerminationResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1GetVoiceConnectorTerminationCommand, serializeAws_restJson1GetVoiceConnectorTerminationCommand, } from "../protocols/Aws_restJson1";
-export class GetVoiceConnectorTerminationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetVoiceConnectorTerminationCommand = (function (_super) {
+    __extends(GetVoiceConnectorTerminationCommand, _super);
+    function GetVoiceConnectorTerminationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetVoiceConnectorTerminationCommand.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 = "GetVoiceConnectorTerminationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetVoiceConnectorTerminationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetVoiceConnectorTerminationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetVoiceConnectorTerminationResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetVoiceConnectorTerminationCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetVoiceConnectorTerminationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetVoiceConnectorTerminationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetVoiceConnectorTerminationCommand(output, context);
-    }
-}
+    };
+    return GetVoiceConnectorTerminationCommand;
+}($Command));
+export { GetVoiceConnectorTerminationCommand };

package/dist-es/commands/GetVoiceConnectorTerminationHealthCommand.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 { GetVoiceConnectorTerminationHealthRequestFilterSensitiveLog, GetVoiceConnectorTerminationHealthResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1GetVoiceConnectorTerminationHealthCommand, serializeAws_restJson1GetVoiceConnectorTerminationHealthCommand, } from "../protocols/Aws_restJson1";
-export class GetVoiceConnectorTerminationHealthCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetVoiceConnectorTerminationHealthCommand = (function (_super) {
+    __extends(GetVoiceConnectorTerminationHealthCommand, _super);
+    function GetVoiceConnectorTerminationHealthCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetVoiceConnectorTerminationHealthCommand.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 = "GetVoiceConnectorTerminationHealthCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeClient";
+        var commandName = "GetVoiceConnectorTerminationHealthCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetVoiceConnectorTerminationHealthRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetVoiceConnectorTerminationHealthResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetVoiceConnectorTerminationHealthCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetVoiceConnectorTerminationHealthCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetVoiceConnectorTerminationHealthCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetVoiceConnectorTerminationHealthCommand(output, context);
-    }
-}
+    };
+    return GetVoiceConnectorTerminationHealthCommand;
+}($Command));
+export { GetVoiceConnectorTerminationHealthCommand };