@aws-sdk/client-lex-models-v2 3.451.0 → 3.458.0

package/dist-es/commands/ListBotResourceGenerationsCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_ListBotResourceGenerationsCommand, se_ListBotResourceGenerationsCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListBotResourceGenerationsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListBotResourceGenerationsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LexModelsV2Client";
+        const commandName = "ListBotResourceGenerationsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "LexModelBuildingServiceV2",
+                operation: "ListBotResourceGenerations",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListBotResourceGenerationsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListBotResourceGenerationsCommand(output, context);
+    }
+}

package/dist-es/commands/StartBotResourceGenerationCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_StartBotResourceGenerationCommand, se_StartBotResourceGenerationCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class StartBotResourceGenerationCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, StartBotResourceGenerationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LexModelsV2Client";
+        const commandName = "StartBotResourceGenerationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "LexModelBuildingServiceV2",
+                operation: "StartBotResourceGeneration",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_StartBotResourceGenerationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_StartBotResourceGenerationCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -32,6 +32,7 @@ export * from "./DescribeBotAliasCommand";
 export * from "./DescribeBotCommand";
 export * from "./DescribeBotLocaleCommand";
 export * from "./DescribeBotRecommendationCommand";
+export * from "./DescribeBotResourceGenerationCommand";
 export * from "./DescribeBotVersionCommand";
 export * from "./DescribeCustomVocabularyMetadataCommand";
 export * from "./DescribeExportCommand";
@@ -44,11 +45,13 @@ export * from "./DescribeTestExecutionCommand";
 export * from "./DescribeTestSetCommand";
 export * from "./DescribeTestSetDiscrepancyReportCommand";
 export * from "./DescribeTestSetGenerationCommand";
+export * from "./GenerateBotElementCommand";
 export * from "./GetTestExecutionArtifactsUrlCommand";
 export * from "./ListAggregatedUtterancesCommand";
 export * from "./ListBotAliasesCommand";
 export * from "./ListBotLocalesCommand";
 export * from "./ListBotRecommendationsCommand";
+export * from "./ListBotResourceGenerationsCommand";
 export * from "./ListBotVersionsCommand";
 export * from "./ListBotsCommand";
 export * from "./ListBuiltInIntentsCommand";
@@ -74,6 +77,7 @@ export * from "./ListUtteranceAnalyticsDataCommand";
 export * from "./ListUtteranceMetricsCommand";
 export * from "./SearchAssociatedTranscriptsCommand";
 export * from "./StartBotRecommendationCommand";
+export * from "./StartBotResourceGenerationCommand";
 export * from "./StartImportCommand";
 export * from "./StartTestExecutionCommand";
 export * from "./StartTestSetGenerationCommand";

package/dist-es/models/models_0.js

@@ -395,6 +395,10 @@ export const SlotConstraint = {
     Optional: "Optional",
     Required: "Required",
 };
+export const SlotResolutionStrategy = {
+    Default: "Default",
+    EnhancedFallback: "EnhancedFallback",
+};
 export const SlotValueResolutionStrategy = {
     Concatenation: "Concatenation",
     OriginalValue: "OriginalValue",
@@ -416,15 +420,16 @@ export const ImportStatus = {
 export const TranscriptFormat = {
     Lex: "Lex",
 };
+export const GenerationStatus = {
+    Complete: "Complete",
+    Failed: "Failed",
+    InProgress: "InProgress",
+};
 export const MergeStrategy = {
     Append: "Append",
     FailOnConflict: "FailOnConflict",
     Overwrite: "Overwrite",
 };
-export const TestSetModality = {
-    Audio: "Audio",
-    Text: "Text",
-};
 export const CreateExportRequestFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.filePassword && { filePassword: SENSITIVE_STRING }),

package/dist-es/models/models_1.js

@@ -1,5 +1,9 @@
 import { SENSITIVE_STRING } from "@smithy/smithy-client";
 import { EncryptionSettingFilterSensitiveLog, } from "./models_0";
+export const TestSetModality = {
+    Audio: "Audio",
+    Text: "Text",
+};
 export const TestExecutionApiMode = {
     NonStreaming: "NonStreaming",
     Streaming: "Streaming",
@@ -45,6 +49,10 @@ export const ExportFilterOperator = {
 export const ExportSortAttribute = {
     LastUpdatedDateTime: "LastUpdatedDateTime",
 };
+export const GenerationSortByAttribute = {
+    creationStartTime: "creationStartTime",
+    lastUpdatedTime: "lastUpdatedTime",
+};
 export const ImportFilterName = {
     ImportResourceType: "ImportResourceType",
 };

package/dist-es/pagination/ListBotResourceGenerationsPaginator.js

@@ -0,0 +1,25 @@
+import { ListBotResourceGenerationsCommand, } from "../commands/ListBotResourceGenerationsCommand";
+import { LexModelsV2Client } from "../LexModelsV2Client";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListBotResourceGenerationsCommand(input), ...args);
+};
+export async function* paginateListBotResourceGenerations(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof LexModelsV2Client) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected LexModelsV2 | LexModelsV2Client");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/index.js

@@ -3,6 +3,7 @@ export * from "./ListAggregatedUtterancesPaginator";
 export * from "./ListBotAliasesPaginator";
 export * from "./ListBotLocalesPaginator";
 export * from "./ListBotRecommendationsPaginator";
+export * from "./ListBotResourceGenerationsPaginator";
 export * from "./ListBotVersionsPaginator";
 export * from "./ListBotsPaginator";
 export * from "./ListBuiltInIntentsPaginator";

package/dist-es/protocols/Aws_restJson1.js

@@ -160,6 +160,7 @@ export const se_CreateBotLocaleCommand = async (input, context) => {
     let body;
     body = JSON.stringify(take(input, {
         description: [],
+        generativeAISettings: (_) => _json(_),
         localeId: [],
         nluIntentConfidenceThreshold: (_) => __serializeFloat(_),
         voiceSettings: (_) => _json(_),
@@ -763,6 +764,26 @@ export const se_DescribeBotRecommendationCommand = async (input, context) => {
         body,
     });
 };
+export const se_DescribeBotResourceGenerationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/generations/{generationId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "botId", () => input.botId, "{botId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "botVersion", () => input.botVersion, "{botVersion}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "localeId", () => input.localeId, "{localeId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "generationId", () => input.generationId, "{generationId}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_DescribeBotVersionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -973,6 +994,30 @@ export const se_DescribeTestSetGenerationCommand = async (input, context) => {
         body,
     });
 };
+export const se_GenerateBotElementCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/generate";
+    resolvedPath = __resolvedPath(resolvedPath, input, "botId", () => input.botId, "{botId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "botVersion", () => input.botVersion, "{botVersion}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "localeId", () => input.localeId, "{localeId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        intentId: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_GetTestExecutionArtifactsUrlCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -1091,6 +1136,32 @@ export const se_ListBotRecommendationsCommand = async (input, context) => {
         body,
     });
 };
+export const se_ListBotResourceGenerationsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/generations";
+    resolvedPath = __resolvedPath(resolvedPath, input, "botId", () => input.botId, "{botId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "botVersion", () => input.botVersion, "{botVersion}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "localeId", () => input.localeId, "{localeId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        maxResults: [],
+        nextToken: [],
+        sortBy: (_) => _json(_),
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_ListBotsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -1716,6 +1787,30 @@ export const se_StartBotRecommendationCommand = async (input, context) => {
         body,
     });
 };
+export const se_StartBotResourceGenerationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/bots/{botId}/botversions/{botVersion}/botlocales/{localeId}/startgeneration";
+    resolvedPath = __resolvedPath(resolvedPath, input, "botId", () => input.botId, "{botId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "botVersion", () => input.botVersion, "{botVersion}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "localeId", () => input.localeId, "{localeId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        generationInputPrompt: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_StartImportCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -1918,6 +2013,7 @@ export const se_UpdateBotLocaleCommand = async (input, context) => {
     let body;
     body = JSON.stringify(take(input, {
         description: [],
+        generativeAISettings: (_) => _json(_),
         nluIntentConfidenceThreshold: (_) => __serializeFloat(_),
         voiceSettings: (_) => _json(_),
     }));
@@ -2454,6 +2550,7 @@ export const de_CreateBotLocaleCommand = async (output, context) => {
         botVersion: __expectString,
         creationDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
         description: __expectString,
+        generativeAISettings: _json,
         localeId: __expectString,
         localeName: __expectString,
         nluIntentConfidenceThreshold: __limitedParseDouble,
@@ -3751,6 +3848,7 @@ export const de_DescribeBotLocaleCommand = async (output, context) => {
         creationDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
         description: __expectString,
         failureReasons: _json,
+        generativeAISettings: _json,
         intentsCount: __expectInt32,
         lastBuildSubmittedDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
         lastUpdatedDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
@@ -3847,6 +3945,58 @@ const de_DescribeBotRecommendationCommandError = async (output, context) => {
             });
     }
 };
+export const de_DescribeBotResourceGenerationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DescribeBotResourceGenerationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        botId: __expectString,
+        botVersion: __expectString,
+        creationDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        failureReasons: _json,
+        generatedBotLocaleUrl: __expectString,
+        generationId: __expectString,
+        generationInputPrompt: __expectString,
+        generationStatus: __expectString,
+        lastUpdatedDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        localeId: __expectString,
+        modelArn: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_DescribeBotResourceGenerationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.lexmodelsv2#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.lexmodelsv2#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.lexmodelsv2#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_DescribeBotVersionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_DescribeBotVersionCommandError(output, context);
@@ -4488,6 +4638,61 @@ const de_DescribeTestSetGenerationCommandError = async (output, context) => {
             });
     }
 };
+export const de_GenerateBotElementCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_GenerateBotElementCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        botId: __expectString,
+        botVersion: __expectString,
+        intentId: __expectString,
+        localeId: __expectString,
+        sampleUtterances: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GenerateBotElementCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.lexmodelsv2#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.lexmodelsv2#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "PreconditionFailedException":
+        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
+            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.lexmodelsv2#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.lexmodelsv2#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_GetTestExecutionArtifactsUrlCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_GetTestExecutionArtifactsUrlCommandError(output, context);
@@ -4720,6 +4925,52 @@ const de_ListBotRecommendationsCommandError = async (output, context) => {
             });
     }
 };
+export const de_ListBotResourceGenerationsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListBotResourceGenerationsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        botId: __expectString,
+        botVersion: __expectString,
+        generationSummaries: (_) => de_GenerationSummaryList(_, context),
+        localeId: __expectString,
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListBotResourceGenerationsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.lexmodelsv2#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.lexmodelsv2#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.lexmodelsv2#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_ListBotsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_ListBotsCommandError(output, context);
@@ -5875,6 +6126,60 @@ const de_StartBotRecommendationCommandError = async (output, context) => {
             });
     }
 };
+export const de_StartBotResourceGenerationCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_StartBotResourceGenerationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        botId: __expectString,
+        botVersion: __expectString,
+        creationDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        generationId: __expectString,
+        generationInputPrompt: __expectString,
+        generationStatus: __expectString,
+        localeId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_StartBotResourceGenerationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.lexmodelsv2#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.lexmodelsv2#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "PreconditionFailedException":
+        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
+            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.lexmodelsv2#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.lexmodelsv2#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_StartImportCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
         return de_StartImportCommandError(output, context);
@@ -6298,6 +6603,7 @@ export const de_UpdateBotLocaleCommand = async (output, context) => {
         creationDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
         description: __expectString,
         failureReasons: _json,
+        generativeAISettings: _json,
         lastUpdatedDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
         localeId: __expectString,
         localeName: __expectString,
@@ -7031,6 +7337,7 @@ const se_SlotValueElicitationSetting = (input, context) => {
         sampleUtterances: _json,
         slotCaptureSetting: (_) => se_SlotCaptureSetting(_, context),
         slotConstraint: [],
+        slotResolutionSetting: _json,
         waitAndContinueSpecification: _json,
     });
 };
@@ -7450,6 +7757,22 @@ const de_FulfillmentCodeHookSettings = (output, context) => {
         postFulfillmentStatusSpecification: (_) => de_PostFulfillmentStatusSpecification(_, context),
     });
 };
+const de_GenerationSummary = (output, context) => {
+    return take(output, {
+        creationDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        generationId: __expectString,
+        generationStatus: __expectString,
+        lastUpdatedDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+    });
+};
+const de_GenerationSummaryList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_GenerationSummary(entry, context);
+    });
+    return retVal;
+};
 const de_ImportResourceSpecification = (output, context) => {
     return take(output, {
         botImportSpecification: _json,
@@ -7693,6 +8016,7 @@ const de_SlotValueElicitationSetting = (output, context) => {
         sampleUtterances: _json,
         slotCaptureSetting: (_) => de_SlotCaptureSetting(_, context),
         slotConstraint: __expectString,
+        slotResolutionSetting: _json,
         waitAndContinueSpecification: _json,
     });
 };