@aws-sdk/client-lambda 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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