@aws-sdk/client-lex-models-v2 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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