import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
import * as S from "effect/Schema";
import * as API from "../client/api.js";
import * as T from "../traits.js";
import * as C from "../category.js";
import { SensitiveString } from "../sensitive.js";
const svc = T.AwsApiService({
    sdkId: "Lex Runtime Service",
    serviceShapeName: "AWSDeepSenseRunTimeService",
});
const auth = T.AwsAuthSigv4({ name: "lex" });
const ver = T.ServiceVersion("2016-11-28");
const proto = T.AwsProtocolsRestJson1();
const rules = T.EndpointResolver((p, _) => {
    const { Region, UseDualStack = false, UseFIPS = false, Endpoint } = p;
    const e = (u, p = {}, h = {}) => ({
        type: "endpoint",
        endpoint: { url: u, properties: p, headers: h },
    });
    const err = (m) => ({
        type: "error",
        message: m,
    });
    if (Endpoint != null) {
        if (UseFIPS === true) {
            return err("Invalid Configuration: FIPS and custom endpoint are not supported");
        }
        if (UseDualStack === true) {
            return err("Invalid Configuration: Dualstack and custom endpoint are not supported");
        }
        return e(Endpoint);
    }
    if (Region != null) {
        {
            const PartitionResult = _.partition(Region);
            if (PartitionResult != null && PartitionResult !== false) {
                if (UseFIPS === true && UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsFIPS") &&
                        true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://runtime.lex-fips.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("FIPS and DualStack are enabled, but this partition does not support one or both");
                }
                if (UseFIPS === true) {
                    if (_.getAttr(PartitionResult, "supportsFIPS") === true) {
                        if (_.getAttr(PartitionResult, "name") === "aws") {
                            return e(`https://runtime-fips.lex.${Region}.amazonaws.com`);
                        }
                        if (_.getAttr(PartitionResult, "name") === "aws-us-gov") {
                            return e(`https://runtime-fips.lex.${Region}.amazonaws.com`);
                        }
                        return e(`https://runtime.lex-fips.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
                    }
                    return err("FIPS is enabled but this partition does not support FIPS");
                }
                if (UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://runtime.lex.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("DualStack is enabled but this partition does not support DualStack");
                }
                if ("aws" === _.getAttr(PartitionResult, "name")) {
                    return e(`https://runtime.lex.${Region}.amazonaws.com`);
                }
                if ("aws-us-gov" === _.getAttr(PartitionResult, "name")) {
                    return e(`https://runtime.lex.${Region}.amazonaws.com`);
                }
                return e(`https://runtime.lex.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
            }
        }
    }
    return err("Invalid Configuration: Missing Region");
});
export const DeleteSessionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    botName: S.String.pipe(T.HttpLabel("botName")),
    botAlias: S.String.pipe(T.HttpLabel("botAlias")),
    userId: S.String.pipe(T.HttpLabel("userId")),
}).pipe(T.all(T.Http({
    method: "DELETE",
    uri: "/bot/{botName}/alias/{botAlias}/user/{userId}/session",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteSessionRequest",
});
export const DeleteSessionResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    botName: S.optional(S.String),
    botAlias: S.optional(S.String),
    userId: S.optional(S.String),
    sessionId: S.optional(S.String),
})).annotate({
    identifier: "DeleteSessionResponse",
});
export const GetSessionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    botName: S.String.pipe(T.HttpLabel("botName")),
    botAlias: S.String.pipe(T.HttpLabel("botAlias")),
    userId: S.String.pipe(T.HttpLabel("userId")),
    checkpointLabelFilter: S.optional(S.String).pipe(T.HttpQuery("checkpointLabelFilter")),
}).pipe(T.all(T.Http({
    method: "GET",
    uri: "/bot/{botName}/alias/{botAlias}/user/{userId}/session",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetSessionRequest",
});
export const StringMap = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.String.pipe(S.optional));
export const ConfirmationStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const DialogActionType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const FulfillmentState = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const IntentSummary = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    intentName: S.optional(S.String),
    checkpointLabel: S.optional(S.String),
    slots: S.optional(StringMap),
    confirmationStatus: S.optional(ConfirmationStatus),
    dialogActionType: DialogActionType,
    fulfillmentState: S.optional(FulfillmentState),
    slotToElicit: S.optional(S.String),
})).annotate({ identifier: "IntentSummary" });
export const IntentSummaryList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(IntentSummary);
export const MessageFormatType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const DialogAction = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    type: DialogActionType,
    intentName: S.optional(S.String),
    slots: S.optional(StringMap),
    slotToElicit: S.optional(S.String),
    fulfillmentState: S.optional(FulfillmentState),
    message: S.optional(SensitiveString),
    messageFormat: S.optional(MessageFormatType),
})).annotate({ identifier: "DialogAction" });
export const ActiveContextTimeToLive = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    timeToLiveInSeconds: S.optional(S.Number),
    turnsToLive: S.optional(S.Number),
})).annotate({
    identifier: "ActiveContextTimeToLive",
});
export const ActiveContextParametersMap = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, SensitiveString.pipe(S.optional));
export const ActiveContext = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    name: S.String,
    timeToLive: ActiveContextTimeToLive,
    parameters: ActiveContextParametersMap,
})).annotate({ identifier: "ActiveContext" });
export const ActiveContextsList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ActiveContext);
export const GetSessionResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    recentIntentSummaryView: S.optional(IntentSummaryList),
    sessionAttributes: S.optional(StringMap),
    sessionId: S.optional(S.String),
    dialogAction: S.optional(DialogAction),
    activeContexts: S.optional(ActiveContextsList),
})).annotate({
    identifier: "GetSessionResponse",
});
export const PostContentRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    botName: S.String.pipe(T.HttpLabel("botName")),
    botAlias: S.String.pipe(T.HttpLabel("botAlias")),
    userId: S.String.pipe(T.HttpLabel("userId")),
    sessionAttributes: S.optional(SensitiveString).pipe(T.HttpHeader("x-amz-lex-session-attributes")),
    requestAttributes: S.optional(SensitiveString).pipe(T.HttpHeader("x-amz-lex-request-attributes")),
    contentType: S.String.pipe(T.HttpHeader("Content-Type")),
    accept: S.optional(S.String).pipe(T.HttpHeader("Accept")),
    inputStream: T.StreamingInput.pipe(T.HttpPayload()),
    activeContexts: S.optional(SensitiveString).pipe(T.HttpHeader("x-amz-lex-active-contexts")),
}).pipe(T.all(T.Http({
    method: "POST",
    uri: "/bot/{botName}/alias/{botAlias}/user/{userId}/content",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "PostContentRequest",
});
export const DialogState = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const PostContentResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    contentType: S.optional(S.String).pipe(T.HttpHeader("Content-Type")),
    intentName: S.optional(S.String).pipe(T.HttpHeader("x-amz-lex-intent-name")),
    nluIntentConfidence: S.optional(S.String).pipe(T.HttpHeader("x-amz-lex-nlu-intent-confidence")),
    alternativeIntents: S.optional(S.String).pipe(T.HttpHeader("x-amz-lex-alternative-intents")),
    slots: S.optional(S.String).pipe(T.HttpHeader("x-amz-lex-slots")),
    sessionAttributes: S.optional(S.String).pipe(T.HttpHeader("x-amz-lex-session-attributes")),
    sentimentResponse: S.optional(S.String).pipe(T.HttpHeader("x-amz-lex-sentiment")),
    message: S.optional(SensitiveString).pipe(T.HttpHeader("x-amz-lex-message")),
    encodedMessage: S.optional(SensitiveString).pipe(T.HttpHeader("x-amz-lex-encoded-message")),
    messageFormat: S.optional(MessageFormatType).pipe(T.HttpHeader("x-amz-lex-message-format")),
    dialogState: S.optional(DialogState).pipe(T.HttpHeader("x-amz-lex-dialog-state")),
    slotToElicit: S.optional(S.String).pipe(T.HttpHeader("x-amz-lex-slot-to-elicit")),
    inputTranscript: S.optional(S.String).pipe(T.HttpHeader("x-amz-lex-input-transcript")),
    encodedInputTranscript: S.optional(SensitiveString).pipe(T.HttpHeader("x-amz-lex-encoded-input-transcript")),
    audioStream: S.optional(T.StreamingOutput).pipe(T.HttpPayload()),
    botVersion: S.optional(S.String).pipe(T.HttpHeader("x-amz-lex-bot-version")),
    sessionId: S.optional(S.String).pipe(T.HttpHeader("x-amz-lex-session-id")),
    activeContexts: S.optional(SensitiveString).pipe(T.HttpHeader("x-amz-lex-active-contexts")),
})).annotate({
    identifier: "PostContentResponse",
});
export const PostTextRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    botName: S.String.pipe(T.HttpLabel("botName")),
    botAlias: S.String.pipe(T.HttpLabel("botAlias")),
    userId: S.String.pipe(T.HttpLabel("userId")),
    sessionAttributes: S.optional(StringMap),
    requestAttributes: S.optional(StringMap),
    inputText: SensitiveString,
    activeContexts: S.optional(ActiveContextsList),
}).pipe(T.all(T.Http({
    method: "POST",
    uri: "/bot/{botName}/alias/{botAlias}/user/{userId}/text",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "PostTextRequest",
});
export const IntentConfidence = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ score: S.optional(S.Number) })).annotate({
    identifier: "IntentConfidence",
});
export const PredictedIntent = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    intentName: S.optional(S.String),
    nluIntentConfidence: S.optional(IntentConfidence),
    slots: S.optional(StringMap),
})).annotate({
    identifier: "PredictedIntent",
});
export const IntentList = /*@__PURE__*/ /*#__PURE__*/ S.Array(PredictedIntent);
export const SentimentResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    sentimentLabel: S.optional(S.String),
    sentimentScore: S.optional(S.String),
})).annotate({
    identifier: "SentimentResponse",
});
export const ContentType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Button = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ text: S.String, value: S.String })).annotate({ identifier: "Button" });
export const ListOfButtons = /*@__PURE__*/ /*#__PURE__*/ S.Array(Button);
export const GenericAttachment = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    title: S.optional(S.String),
    subTitle: S.optional(S.String),
    attachmentLinkUrl: S.optional(S.String),
    imageUrl: S.optional(S.String),
    buttons: S.optional(ListOfButtons),
})).annotate({
    identifier: "GenericAttachment",
});
export const GenericAttachmentList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(GenericAttachment);
export const ResponseCard = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    version: S.optional(S.String),
    contentType: S.optional(ContentType),
    genericAttachments: S.optional(GenericAttachmentList),
})).annotate({ identifier: "ResponseCard" });
export const PostTextResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    intentName: S.optional(S.String),
    nluIntentConfidence: S.optional(IntentConfidence),
    alternativeIntents: S.optional(IntentList),
    slots: S.optional(StringMap),
    sessionAttributes: S.optional(StringMap),
    message: S.optional(SensitiveString),
    sentimentResponse: S.optional(SentimentResponse),
    messageFormat: S.optional(MessageFormatType),
    dialogState: S.optional(DialogState),
    slotToElicit: S.optional(S.String),
    responseCard: S.optional(ResponseCard),
    sessionId: S.optional(S.String),
    botVersion: S.optional(S.String),
    activeContexts: S.optional(ActiveContextsList),
})).annotate({
    identifier: "PostTextResponse",
});
export const PutSessionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    botName: S.String.pipe(T.HttpLabel("botName")),
    botAlias: S.String.pipe(T.HttpLabel("botAlias")),
    userId: S.String.pipe(T.HttpLabel("userId")),
    sessionAttributes: S.optional(StringMap),
    dialogAction: S.optional(DialogAction),
    recentIntentSummaryView: S.optional(IntentSummaryList),
    accept: S.optional(S.String).pipe(T.HttpHeader("Accept")),
    activeContexts: S.optional(ActiveContextsList),
}).pipe(T.all(T.Http({
    method: "POST",
    uri: "/bot/{botName}/alias/{botAlias}/user/{userId}/session",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "PutSessionRequest",
});
export const PutSessionResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    contentType: S.optional(S.String).pipe(T.HttpHeader("Content-Type")),
    intentName: S.optional(S.String).pipe(T.HttpHeader("x-amz-lex-intent-name")),
    slots: S.optional(S.String).pipe(T.HttpHeader("x-amz-lex-slots")),
    sessionAttributes: S.optional(S.String).pipe(T.HttpHeader("x-amz-lex-session-attributes")),
    message: S.optional(SensitiveString).pipe(T.HttpHeader("x-amz-lex-message")),
    encodedMessage: S.optional(SensitiveString).pipe(T.HttpHeader("x-amz-lex-encoded-message")),
    messageFormat: S.optional(MessageFormatType).pipe(T.HttpHeader("x-amz-lex-message-format")),
    dialogState: S.optional(DialogState).pipe(T.HttpHeader("x-amz-lex-dialog-state")),
    slotToElicit: S.optional(S.String).pipe(T.HttpHeader("x-amz-lex-slot-to-elicit")),
    audioStream: S.optional(T.StreamingOutput).pipe(T.HttpPayload()),
    sessionId: S.optional(S.String).pipe(T.HttpHeader("x-amz-lex-session-id")),
    activeContexts: S.optional(SensitiveString).pipe(T.HttpHeader("x-amz-lex-active-contexts")),
})).annotate({
    identifier: "PutSessionResponse",
});
//# Errors
export class BadRequestException extends S.TaggedErrorClass()("BadRequestException", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class ConflictException extends S.TaggedErrorClass()("ConflictException", { message: S.optional(S.String) }).pipe(C.withConflictError) {
}
export class InternalFailureException extends S.TaggedErrorClass()("InternalFailureException", { message: S.optional(S.String) }).pipe(C.withServerError) {
}
export class LimitExceededException extends S.TaggedErrorClass()("LimitExceededException", {
    retryAfterSeconds: S.optional(S.String).pipe(T.HttpHeader("Retry-After")),
    message: S.optional(S.String),
}).pipe(C.withThrottlingError) {
}
export class NotFoundException extends S.TaggedErrorClass()("NotFoundException", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class BadGatewayException extends S.TaggedErrorClass()("BadGatewayException", { Message: S.optional(S.String) }).pipe(C.withServerError) {
}
export class DependencyFailedException extends S.TaggedErrorClass()("DependencyFailedException", { Message: S.optional(S.String) }) {
}
export class LoopDetectedException extends S.TaggedErrorClass()("LoopDetectedException", { Message: S.optional(S.String) }).pipe(C.withServerError) {
}
export class NotAcceptableException extends S.TaggedErrorClass()("NotAcceptableException", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class RequestTimeoutException extends S.TaggedErrorClass()("RequestTimeoutException", { message: S.optional(S.String) }).pipe(C.withTimeoutError) {
}
export class UnsupportedMediaTypeException extends S.TaggedErrorClass()("UnsupportedMediaTypeException", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
/**
 * Removes session information for a specified bot, alias, and user ID.
 */
export const deleteSession = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteSessionRequest,
    output: DeleteSessionResponse,
    errors: [
        BadRequestException,
        ConflictException,
        InternalFailureException,
        LimitExceededException,
        NotFoundException,
    ],
}));
/**
 * Returns session information for a specified bot, alias, and user
 * ID.
 */
export const getSession = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetSessionRequest,
    output: GetSessionResponse,
    errors: [
        BadRequestException,
        InternalFailureException,
        LimitExceededException,
        NotFoundException,
    ],
}));
/**
 * Sends user input (text or speech) to Amazon Lex. Clients use this API to
 * send text and audio requests to Amazon Lex at runtime. Amazon Lex interprets the
 * user input using the machine learning model that it built for the bot.
 *
 * The `PostContent` operation supports audio input at 8kHz
 * and 16kHz. You can use 8kHz audio to achieve higher speech recognition
 * accuracy in telephone audio applications.
 *
 * In response, Amazon Lex returns the next message to convey to the user.
 * Consider the following example messages:
 *
 * - For a user input "I would like a pizza," Amazon Lex might return a
 * response with a message eliciting slot data (for example,
 * `PizzaSize`): "What size pizza would you like?".
 *
 * - After the user provides all of the pizza order information, Amazon Lex
 * might return a response with a message to get user confirmation:
 * "Order the pizza?".
 *
 * - After the user replies "Yes" to the confirmation prompt, Amazon Lex
 * might return a conclusion statement: "Thank you, your cheese pizza has
 * been ordered.".
 *
 * Not all Amazon Lex messages require a response from the user. For example,
 * conclusion statements do not require a response. Some messages require
 * only a yes or no response. In addition to the `message`, Amazon Lex
 * provides additional context about the message in the response that you can
 * use to enhance client behavior, such as displaying the appropriate client
 * user interface. Consider the following examples:
 *
 * - If the message is to elicit slot data, Amazon Lex returns the
 * following context information:
 *
 * - `x-amz-lex-dialog-state` header set to
 * `ElicitSlot`
 *
 * - `x-amz-lex-intent-name` header set to the intent name
 * in the current context
 *
 * - `x-amz-lex-slot-to-elicit` header set to the slot name
 * for which the `message` is eliciting information
 *
 * - `x-amz-lex-slots` header set to a map of slots
 * configured for the intent with their current values
 *
 * - If the message is a confirmation prompt, the
 * `x-amz-lex-dialog-state` header is set to
 * `Confirmation` and the
 * `x-amz-lex-slot-to-elicit` header is omitted.
 *
 * - If the message is a clarification prompt configured for the
 * intent, indicating that the user intent is not understood, the
 * `x-amz-dialog-state` header is set to
 * `ElicitIntent` and the `x-amz-slot-to-elicit`
 * header is omitted.
 *
 * In addition, Amazon Lex also returns your application-specific
 * `sessionAttributes`. For more information, see Managing
 * Conversation Context.
 */
export const postContent = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PostContentRequest,
    output: PostContentResponse,
    errors: [
        BadGatewayException,
        BadRequestException,
        ConflictException,
        DependencyFailedException,
        InternalFailureException,
        LimitExceededException,
        LoopDetectedException,
        NotAcceptableException,
        NotFoundException,
        RequestTimeoutException,
        UnsupportedMediaTypeException,
    ],
}));
/**
 * Sends user input to Amazon Lex. Client applications can use this API to
 * send requests to Amazon Lex at runtime. Amazon Lex then interprets the user input
 * using the machine learning model it built for the bot.
 *
 * In response, Amazon Lex returns the next `message` to convey to
 * the user an optional `responseCard` to display. Consider the
 * following example messages:
 *
 * - For a user input "I would like a pizza", Amazon Lex might return a
 * response with a message eliciting slot data (for example, PizzaSize):
 * "What size pizza would you like?"
 *
 * - After the user provides all of the pizza order information,
 * Amazon Lex might return a response with a message to obtain user
 * confirmation "Proceed with the pizza order?".
 *
 * - After the user replies to a confirmation prompt with a "yes",
 * Amazon Lex might return a conclusion statement: "Thank you, your cheese
 * pizza has been ordered.".
 *
 * Not all Amazon Lex messages require a user response. For example, a
 * conclusion statement does not require a response. Some messages require
 * only a "yes" or "no" user response. In addition to the
 * `message`, Amazon Lex provides additional context about the
 * message in the response that you might use to enhance client behavior, for
 * example, to display the appropriate client user interface. These are the
 * `slotToElicit`, `dialogState`,
 * `intentName`, and `slots` fields in the response.
 * Consider the following examples:
 *
 * - If the message is to elicit slot data, Amazon Lex returns the
 * following context information:
 *
 * - `dialogState` set to ElicitSlot
 *
 * - `intentName` set to the intent name in the current
 * context
 *
 * - `slotToElicit` set to the slot name for which the
 * `message` is eliciting information
 *
 * - `slots` set to a map of slots, configured for the
 * intent, with currently known values
 *
 * - If the message is a confirmation prompt, the
 * `dialogState` is set to ConfirmIntent and
 * `SlotToElicit` is set to null.
 *
 * - If the message is a clarification prompt (configured for the
 * intent) that indicates that user intent is not understood, the
 * `dialogState` is set to ElicitIntent and
 * `slotToElicit` is set to null.
 *
 * In addition, Amazon Lex also returns your application-specific
 * `sessionAttributes`. For more information, see Managing
 * Conversation Context.
 */
export const postText = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PostTextRequest,
    output: PostTextResponse,
    errors: [
        BadGatewayException,
        BadRequestException,
        ConflictException,
        DependencyFailedException,
        InternalFailureException,
        LimitExceededException,
        LoopDetectedException,
        NotFoundException,
    ],
}));
/**
 * Creates a new session or modifies an existing session with an Amazon Lex
 * bot. Use this operation to enable your application to set the state of the
 * bot.
 *
 * For more information, see Managing
 * Sessions.
 */
export const putSession = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PutSessionRequest,
    output: PutSessionResponse,
    errors: [
        BadGatewayException,
        BadRequestException,
        ConflictException,
        DependencyFailedException,
        InternalFailureException,
        LimitExceededException,
        NotAcceptableException,
        NotFoundException,
    ],
}));
//# sourceMappingURL=lex-runtime-service.js.map