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

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

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

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

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

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

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

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

package/dist-es/commands/UpdateSlotTypeCommand.js

@@ -1,33 +1,40 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { UpdateSlotTypeRequestFilterSensitiveLog } from "../models/models_0";
 import { UpdateSlotTypeResponseFilterSensitiveLog } from "../models/models_1";
 import { deserializeAws_restJson1UpdateSlotTypeCommand, serializeAws_restJson1UpdateSlotTypeCommand, } from "../protocols/Aws_restJson1";
-export class UpdateSlotTypeCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateSlotTypeCommand = (function (_super) {
+    __extends(UpdateSlotTypeCommand, _super);
+    function UpdateSlotTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateSlotTypeCommand.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 = "UpdateSlotTypeCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LexModelsV2Client";
+        var commandName = "UpdateSlotTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateSlotTypeRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateSlotTypeResponseFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateSlotTypeCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateSlotTypeCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateSlotTypeCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateSlotTypeCommand(output, context);
-    }
-}
+    };
+    return UpdateSlotTypeCommand;
+}($Command));
+export { UpdateSlotTypeCommand };

package/dist-es/endpoints.js

@@ -1,6 +1,7 @@
+import { __assign, __awaiter, __generator } from "tslib";
 import { getRegionInfo } from "@aws-sdk/config-resolver";
-const regionHash = {};
-const partitionHash = {
+var regionHash = {};
+var partitionHash = {
     aws: {
         regions: [
             "af-south-1",
@@ -120,9 +121,8 @@ const partitionHash = {
         ],
     },
 };
-export const defaultRegionInfoProvider = async (region, options) => getRegionInfo(region, {
-    ...options,
-    signingService: "lex",
-    regionHash,
-    partitionHash,
-});
+export var defaultRegionInfoProvider = function (region, options) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2, getRegionInfo(region, __assign(__assign({}, options), { signingService: "lex", regionHash: regionHash, partitionHash: partitionHash }))];
+    });
+}); };

package/dist-es/models/LexModelsV2ServiceException.js

@@ -1,7 +1,12 @@
+import { __extends } from "tslib";
 import { ServiceException as __ServiceException, } from "@aws-sdk/smithy-client";
-export class LexModelsV2ServiceException extends __ServiceException {
-    constructor(options) {
-        super(options);
-        Object.setPrototypeOf(this, LexModelsV2ServiceException.prototype);
+var LexModelsV2ServiceException = (function (_super) {
+    __extends(LexModelsV2ServiceException, _super);
+    function LexModelsV2ServiceException(options) {
+        var _this = _super.call(this, options) || this;
+        Object.setPrototypeOf(_this, LexModelsV2ServiceException.prototype);
+        return _this;
     }
-}
+    return LexModelsV2ServiceException;
+}(__ServiceException));
+export { LexModelsV2ServiceException };