lexruntimeservice

type Client struct {
	// contains filtered or unexported fields
}

type DeleteSessionInput struct {
	// The identifier of the user associated with the session data.
	UserId *string
	// The name of the bot that contains the session data.
	BotName *string
	// The alias in use for the bot that contains the session data.
	BotAlias *string
}

type DeleteSessionOutput struct {
	// The alias in use for the bot associated with the session data.
	BotAlias *string
	// The unique identifier for the session.
	SessionId *string
	// The ID of the client application user.
	UserId *string
	// The name of the bot associated with the session data.
	BotName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type EndpointResolver interface {
	ResolveEndpoint(region string, options ResolverOptions) (aws.Endpoint, error)
}

type EndpointResolverFunc func(region string, options ResolverOptions) (aws.Endpoint, error)

type GetSessionInput struct {
	// The name of the bot that contains the session data.
	BotName *string
	// A string used to filter the intents returned in the recentIntentSummaryView
	// structure. When you specify a filter, only intents with their checkpointLabel
	// field set to that string are returned.
	CheckpointLabelFilter *string
	// The alias in use for the bot that contains the session data.
	BotAlias *string
	// The ID of the client application user. Amazon Lex uses this to identify a user's
	// conversation with your bot.
	UserId *string
}

type GetSessionOutput struct {
	// Describes the current state of the bot.
	DialogAction *types.DialogAction
	// A unique identifier for the session.
	SessionId *string
	// An array of information about the intents used in the session. The array can
	// contain a maximum of three summaries. If more than three intents are used in the
	// session, the recentIntentSummaryView operation contains information about the
	// last three intents used. If you set the checkpointLabelFilter parameter in the
	// request, the array contains only the intents with the specified label.
	RecentIntentSummaryView []*types.IntentSummary
	// Map of key/value pairs representing the session-specific context information. It
	// contains application information passed between Amazon Lex and a client
	// application.
	SessionAttributes map[string]*string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type HTTPClient interface {
	Do(*http.Request) (*http.Response, error)
}

type HTTPSignerV4 interface {
	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time) error
}

type Options struct {
	// Set of options to modify how an operation is invoked. These apply to all
	// operations invoked for this client. Use functional options on operation call to
	// modify this list for per operation behavior.
	APIOptions []func(*middleware.Stack) error

	// The credentials object to use when signing requests.
	Credentials aws.CredentialsProvider

	// The endpoint options to be used when attempting to resolve an endpoint.
	EndpointOptions ResolverOptions

	// The service endpoint resolver.
	EndpointResolver EndpointResolver

	// Signature Version 4 (SigV4) Signer
	HTTPSignerV4 HTTPSignerV4

	// The region to send requests to. (Required)
	Region string

	// Retryer guides how HTTP requests should be retried in case of recoverable
	// failures. When nil the API client will use a default retryer.
	Retryer retry.Retryer

	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
	// implementation if nil.
	HTTPClient HTTPClient
}

type PostContentInput struct {
	// User input in PCM or Opus audio format or text format as described in the
	// Content-Type HTTP header. You can stream audio data to Amazon Lex or you can
	// create a local buffer that captures all of the audio data before sending. In
	// general, you get better performance if you stream audio data rather than
	// buffering the data locally.
	InputStream io.Reader
	// You pass this value as the x-amz-lex-session-attributes HTTP header.
	// Application-specific information passed between Amazon Lex and a client
	// application. The value must be a JSON serialized and base64 encoded map with
	// string keys and values. The total size of the sessionAttributes and
	// requestAttributes headers is limited to 12 KB. For more information, see Setting
	// Session Attributes
	// (https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-session-attribs).
	// This value conforms to the media type: application/json
	SessionAttributes *string
	// You pass this value as the x-amz-lex-request-attributes HTTP header.
	// Request-specific information passed between Amazon Lex and a client application.
	// The value must be a JSON serialized and base64 encoded map with string keys and
	// values. The total size of the requestAttributes and sessionAttributes headers is
	// limited to 12 KB. The namespace x-amz-lex: is reserved for special attributes.
	// Don't create any request attributes with the prefix x-amz-lex:. For more
	// information, see Setting Request Attributes
	// (https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-request-attribs).
	// This value conforms to the media type: application/json
	RequestAttributes *string
	// You pass this value as the Accept HTTP header. The message Amazon Lex returns in
	// the response can be either text or speech based on the Accept HTTP header value
	// in the request.
	//
	//     * If the value is text/plain; charset=utf-8, Amazon Lex
	// returns text in the response.
	//
	//     * If the value begins with audio/, Amazon Lex
	// returns speech in the response. Amazon Lex uses Amazon Polly to generate the
	// speech (using the configuration you specified in the Accept header). For
	// example, if you specify audio/mpeg as the value, Amazon Lex returns speech in
	// the MPEG format.
	//
	//     * If the value is audio/pcm, the speech returned is
	// audio/pcm in 16-bit, little endian format.
	//
	//     * The following are the accepted
	// values:
	//
	//         * audio/mpeg
	//
	//         * audio/ogg
	//
	//         * audio/pcm
	//
	//
	// * text/plain; charset=utf-8
	//
	//         * audio/* (defaults to mpeg)
	Accept *string
	// You pass this value as the Content-Type HTTP header. Indicates the audio format
	// or text. The header value must start with one of the following prefixes:
	//
	//     *
	// PCM format, audio data must be in little-endian byte order.
	//
	//         *
	// audio/l16; rate=16000; channels=1
	//
	//         * audio/x-l16; sample-rate=16000;
	// channel-count=1
	//
	//         * audio/lpcm; sample-rate=8000; sample-size-bits=16;
	// channel-count=1; is-big-endian=false
	//
	//     * Opus format
	//
	//         *
	// audio/x-cbr-opus-with-preamble; preamble-size=0; bit-rate=256000;
	// frame-size-milliseconds=4
	//
	//     * Text format
	//
	//         * text/plain;
	// charset=utf-8
	ContentType *string
	// The ID of the client application user. Amazon Lex uses this to identify a user's
	// conversation with your bot. At runtime, each request must contain the userID
	// field. To decide the user ID to use for your application, consider the following
	// factors.
	//
	//     * The userID field must not contain any personally identifiable
	// information of the user, for example, name, personal identification numbers, or
	// other end user personal information.
	//
	//     * If you want a user to start a
	// conversation on one device and continue on another device, use a user-specific
	// identifier.
	//
	//     * If you want the same user to be able to have two independent
	// conversations on two different devices, choose a device-specific identifier.
	//
	//
	// * A user can't have two independent conversations with two different versions of
	// the same bot. For example, a user can't have a conversation with the PROD and
	// BETA versions of the same bot. If you anticipate that a user will need to have
	// conversation with two different versions, for example, while testing, include
	// the bot alias in the user ID to separate the two conversations.
	UserId *string
	// Name of the Amazon Lex bot.
	BotName *string
	// Alias of the Amazon Lex bot.
	BotAlias *string
}

type PostContentOutput struct {
	// The message to convey to the user. The message can come from the bot's
	// configuration or from a Lambda function. If the intent is not configured with a
	// Lambda function, or if the Lambda function returned Delegate as the
	// dialogAction.type in its response, Amazon Lex decides on the next course of
	// action and selects an appropriate message from the bot's configuration based on
	// the current interaction context. For example, if Amazon Lex isn't able to
	// understand user input, it uses a clarification prompt message. When you create
	// an intent you can assign messages to groups. When messages are assigned to
	// groups Amazon Lex returns one message from each group in the response. The
	// message field is an escaped JSON string containing the messages. For more
	// information about the structure of the JSON string returned, see
	// msg-prompts-formats (). If the Lambda function returns a message, Amazon Lex
	// passes it to the client in its response.
	Message *string
	// Map of zero or more intent slots (name/value pairs) Amazon Lex detected from the
	// user input during the conversation. The field is base-64 encoded. Amazon Lex
	// creates a resolution list containing likely values for a slot. The value that it
	// returns is determined by the valueSelectionStrategy selected when the slot type
	// was created or updated. If valueSelectionStrategy is set to ORIGINAL_VALUE, the
	// value provided by the user is returned, if the user value is similar to the slot
	// values. If valueSelectionStrategy is set to TOP_RESOLUTION Amazon Lex returns
	// the first value in the resolution list or, if there is no resolution list, null.
	// If you don't specify a valueSelectionStrategy, the default is ORIGINAL_VALUE.
	// This value conforms to the media type: application/json
	Slots *string
	// The prompt (or statement) to convey to the user. This is based on the bot
	// configuration and context. For example, if Amazon Lex did not understand the
	// user intent, it sends the clarificationPrompt configured for the bot. If the
	// intent requires confirmation before taking the fulfillment action, it sends the
	// confirmationPrompt. Another example: Suppose that the Lambda function
	// successfully fulfilled the intent, and sent a message to convey to the user.
	// Then Amazon Lex sends that message in the response.
	AudioStream io.ReadCloser
	// Identifies the current state of the user interaction. Amazon Lex returns one of
	// the following values as dialogState. The client can optionally use this
	// information to customize the user interface.
	//
	//     * ElicitIntent - Amazon Lex
	// wants to elicit the user's intent. Consider the following examples: For example,
	// a user might utter an intent ("I want to order a pizza"). If Amazon Lex cannot
	// infer the user intent from this utterance, it will return this dialog state.
	//
	//
	// * ConfirmIntent - Amazon Lex is expecting a "yes" or "no" response. For example,
	// Amazon Lex wants user confirmation before fulfilling an intent. Instead of a
	// simple "yes" or "no" response, a user might respond with additional information.
	// For example, "yes, but make it a thick crust pizza" or "no, I want to order a
	// drink." Amazon Lex can process such additional information (in these examples,
	// update the crust type slot or change the intent from OrderPizza to
	// OrderDrink).
	//
	//     * ElicitSlot - Amazon Lex is expecting the value of a slot for
	// the current intent. For example, suppose that in the response Amazon Lex sends
	// this message: "What size pizza would you like?". A user might reply with the
	// slot value (e.g., "medium"). The user might also provide additional information
	// in the response (e.g., "medium thick crust pizza"). Amazon Lex can process such
	// additional information appropriately.
	//
	//     * Fulfilled - Conveys that the Lambda
	// function has successfully fulfilled the intent.
	//
	//     * ReadyForFulfillment -
	// Conveys that the client has to fulfill the request.
	//
	//     * Failed - Conveys that
	// the conversation with the user failed. This can happen for various reasons,
	// including that the user does not provide an appropriate response to prompts from
	// the service (you can configure how many times Amazon Lex can prompt a user for
	// specific information), or if the Lambda function fails to fulfill the intent.
	DialogState types.DialogState
	// Current user intent that Amazon Lex is aware of.
	IntentName *string
	// The text used to process the request. If the input was an audio stream, the
	// inputTranscript field contains the text extracted from the audio stream. This is
	// the text that is actually processed to recognize intents and slot values. You
	// can use this information to determine if Amazon Lex is correctly processing the
	// audio that you send.
	InputTranscript *string
	// The format of the response message. One of the following values:
	//
	//     *
	// PlainText - The message contains plain UTF-8 text.
	//
	//     * CustomPayload - The
	// message is a custom format for the client.
	//
	//     * SSML - The message contains
	// text formatted for voice output.
	//
	//     * Composite - The message contains an
	// escaped JSON object containing one or more messages from the groups that
	// messages were assigned to when the intent was created.
	MessageFormat types.MessageFormatType
	// Content type as specified in the Accept HTTP header in the request.
	ContentType *string
	// The unique identifier for the session.
	SessionId *string
	// Map of key/value pairs representing the session-specific context information.
	// This value conforms to the media type: application/json
	SessionAttributes *string
	// The sentiment expressed in and utterance. When the bot is configured to send
	// utterances to Amazon Comprehend for sentiment analysis, this field contains the
	// result of the analysis.
	SentimentResponse *string
	// If the dialogState value is ElicitSlot, returns the name of the slot for which
	// Amazon Lex is eliciting a value.
	SlotToElicit *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type PostTextInput struct {
	// The ID of the client application user. Amazon Lex uses this to identify a user's
	// conversation with your bot. At runtime, each request must contain the userID
	// field. To decide the user ID to use for your application, consider the following
	// factors.
	//
	//     * The userID field must not contain any personally identifiable
	// information of the user, for example, name, personal identification numbers, or
	// other end user personal information.
	//
	//     * If you want a user to start a
	// conversation on one device and continue on another device, use a user-specific
	// identifier.
	//
	//     * If you want the same user to be able to have two independent
	// conversations on two different devices, choose a device-specific identifier.
	//
	//
	// * A user can't have two independent conversations with two different versions of
	// the same bot. For example, a user can't have a conversation with the PROD and
	// BETA versions of the same bot. If you anticipate that a user will need to have
	// conversation with two different versions, for example, while testing, include
	// the bot alias in the user ID to separate the two conversations.
	UserId *string
	// The text that the user entered (Amazon Lex interprets this text).
	InputText *string
	// The name of the Amazon Lex bot.
	BotName *string
	// The alias of the Amazon Lex bot.
	BotAlias *string
	// Application-specific information passed between Amazon Lex and a client
	// application. For more information, see Setting Session Attributes
	// (https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-session-attribs).
	SessionAttributes map[string]*string
	// Request-specific information passed between Amazon Lex and a client application.
	// The namespace x-amz-lex: is reserved for special attributes. Don't create any
	// request attributes with the prefix x-amz-lex:. For more information, see Setting
	// Request Attributes
	// (https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-request-attribs).
	RequestAttributes map[string]*string
}

type PostTextOutput struct {
	// The message to convey to the user. The message can come from the bot's
	// configuration or from a Lambda function. If the intent is not configured with a
	// Lambda function, or if the Lambda function returned Delegate as the
	// dialogAction.type its response, Amazon Lex decides on the next course of action
	// and selects an appropriate message from the bot's configuration based on the
	// current interaction context. For example, if Amazon Lex isn't able to understand
	// user input, it uses a clarification prompt message. When you create an intent
	// you can assign messages to groups. When messages are assigned to groups Amazon
	// Lex returns one message from each group in the response. The message field is an
	// escaped JSON string containing the messages. For more information about the
	// structure of the JSON string returned, see msg-prompts-formats (). If the Lambda
	// function returns a message, Amazon Lex passes it to the client in its response.
	Message *string
	// The intent slots that Amazon Lex detected from the user input in the
	// conversation. Amazon Lex creates a resolution list containing likely values for
	// a slot. The value that it returns is determined by the valueSelectionStrategy
	// selected when the slot type was created or updated. If valueSelectionStrategy is
	// set to ORIGINAL_VALUE, the value provided by the user is returned, if the user
	// value is similar to the slot values. If valueSelectionStrategy is set to
	// TOP_RESOLUTION Amazon Lex returns the first value in the resolution list or, if
	// there is no resolution list, null. If you don't specify a
	// valueSelectionStrategy, the default is ORIGINAL_VALUE.
	Slots map[string]*string
	// Represents the options that the user has to respond to the current prompt.
	// Response Card can come from the bot configuration (in the Amazon Lex console,
	// choose the settings button next to a slot) or from a code hook (Lambda
	// function).
	ResponseCard *types.ResponseCard
	// The sentiment expressed in and utterance. When the bot is configured to send
	// utterances to Amazon Comprehend for sentiment analysis, this field contains the
	// result of the analysis.
	SentimentResponse *types.SentimentResponse
	// If the dialogState value is ElicitSlot, returns the name of the slot for which
	// Amazon Lex is eliciting a value.
	SlotToElicit *string
	// The format of the response message. One of the following values:
	//
	//     *
	// PlainText - The message contains plain UTF-8 text.
	//
	//     * CustomPayload - The
	// message is a custom format defined by the Lambda function.
	//
	//     * SSML - The
	// message contains text formatted for voice output.
	//
	//     * Composite - The message
	// contains an escaped JSON object containing one or more messages from the groups
	// that messages were assigned to when the intent was created.
	MessageFormat types.MessageFormatType
	// A unique identifier for the session.
	SessionId *string
	// A map of key-value pairs representing the session-specific context information.
	SessionAttributes map[string]*string
	// Identifies the current state of the user interaction. Amazon Lex returns one of
	// the following values as dialogState. The client can optionally use this
	// information to customize the user interface.
	//
	//     * ElicitIntent - Amazon Lex
	// wants to elicit user intent. For example, a user might utter an intent ("I want
	// to order a pizza"). If Amazon Lex cannot infer the user intent from this
	// utterance, it will return this dialogState.
	//
	//     * ConfirmIntent - Amazon Lex is
	// expecting a "yes" or "no" response. For example, Amazon Lex wants user
	// confirmation before fulfilling an intent. Instead of a simple "yes" or "no," a
	// user might respond with additional information. For example, "yes, but make it
	// thick crust pizza" or "no, I want to order a drink". Amazon Lex can process such
	// additional information (in these examples, update the crust type slot value, or
	// change intent from OrderPizza to OrderDrink).
	//
	//     * ElicitSlot - Amazon Lex is
	// expecting a slot value for the current intent. For example, suppose that in the
	// response Amazon Lex sends this message: "What size pizza would you like?". A
	// user might reply with the slot value (e.g., "medium"). The user might also
	// provide additional information in the response (e.g., "medium thick crust
	// pizza"). Amazon Lex can process such additional information appropriately.
	//
	//
	// * Fulfilled - Conveys that the Lambda function configured for the intent has
	// successfully fulfilled the intent.  </li> <li> <p>
	// <code>ReadyForFulfillment</code> - Conveys that the client has to fulfill the
	// intent. </p> </li> <li> <p> <code>Failed</code> - Conveys that the conversation
	// with the user failed. </p> <p> This can happen for various reasons including
	// that the user did not provide an appropriate response to prompts from the
	// service (you can configure how many times Amazon Lex can prompt a user for
	// specific information), or the Lambda function failed to fulfill the intent. </p>
	// </li> </ul>
	DialogState types.DialogState
	// The current user intent that Amazon Lex is aware of.
	IntentName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type PutSessionInput struct {
	// The ID of the client application user. Amazon Lex uses this to identify a user's
	// conversation with your bot.
	UserId *string
	// The name of the bot that contains the session data.
	BotName *string
	// The alias in use for the bot that contains the session data.
	BotAlias *string
	// Sets the next action that the bot should take to fulfill the conversation.
	DialogAction *types.DialogAction
	// A summary of the recent intents for the bot. You can use the intent summary view
	// to set a checkpoint label on an intent and modify attributes of intents. You can
	// also use it to remove or add intent summary objects to the list. An intent that
	// you modify or add to the list must make sense for the bot. For example, the
	// intent name must be valid for the bot. You must provide valid values for:
	//
	//     *
	// intentName
	//
	//     * slot names
	//
	//     * slotToElict
	//
	// If you send the
	// recentIntentSummaryView parameter in a PutSession request, the contents of the
	// new summary view replaces the old summary view. For example, if a GetSession
	// request returns three intents in the summary view and you call PutSession with
	// one intent in the summary view, the next call to GetSession will only return one
	// intent.
	RecentIntentSummaryView []*types.IntentSummary
	// The message that Amazon Lex returns in the response can be either text or speech
	// based depending on the value of this field.
	//
	//     * If the value is text/plain;
	// charset=utf-8, Amazon Lex returns text in the response.
	//
	//     * If the value
	// begins with audio/, Amazon Lex returns speech in the response. Amazon Lex uses
	// Amazon Polly to generate the speech in the configuration that you specify. For
	// example, if you specify audio/mpeg as the value, Amazon Lex returns speech in
	// the MPEG format.
	//
	//     * If the value is audio/pcm, the speech is returned as
	// audio/pcm in 16-bit, little endian format.
	//
	//     * The following are the accepted
	// values:
	//
	//         * audio/mpeg
	//
	//         * audio/ogg
	//
	//         * audio/pcm
	//
	//
	// * audio/* (defaults to mpeg)
	//
	//         * text/plain; charset=utf-8
	Accept *string
	// Map of key/value pairs representing the session-specific context information. It
	// contains application information passed between Amazon Lex and a client
	// application.
	SessionAttributes map[string]*string
}

type PutSessionOutput struct {
	// Map of zero or more intent slots Amazon Lex detected from the user input during
	// the conversation. Amazon Lex creates a resolution list containing likely values
	// for a slot. The value that it returns is determined by the
	// valueSelectionStrategy selected when the slot type was created or updated. If
	// valueSelectionStrategy is set to ORIGINAL_VALUE, the value provided by the user
	// is returned, if the user value is similar to the slot values. If
	// valueSelectionStrategy is set to TOP_RESOLUTION Amazon Lex returns the first
	// value in the resolution list or, if there is no resolution list, null. If you
	// don't specify a valueSelectionStrategy the default is ORIGINAL_VALUE.
	// This value conforms to the media type: application/json
	Slots *string
	// The format of the response message. One of the following values:
	//
	//     *
	// PlainText - The message contains plain UTF-8 text.
	//
	//     * CustomPayload - The
	// message is a custom format for the client.
	//
	//     * SSML - The message contains
	// text formatted for voice output.
	//
	//     * Composite - The message contains an
	// escaped JSON object containing one or more messages from the groups that
	// messages were assigned to when the intent was created.
	MessageFormat types.MessageFormatType
	// The name of the current intent.
	IntentName *string
	// A unique identifier for the session.
	SessionId *string
	// Map of key/value pairs representing session-specific context information.
	// This value conforms to the media type: application/json
	SessionAttributes *string
	// * ConfirmIntent - Amazon Lex is expecting a "yes" or "no" response to confirm
	// the intent before fulfilling an intent.
	//
	//     * ElicitIntent - Amazon Lex wants
	// to elicit the user's intent.
	//
	//     * ElicitSlot - Amazon Lex is expecting the
	// value of a slot for the current intent.
	//
	//     * Failed - Conveys that the
	// conversation with the user has failed. This can happen for various reasons,
	// including the user does not provide an appropriate response to prompts from the
	// service, or if the Lambda function fails to fulfill the intent.
	//
	//     * Fulfilled
	// - Conveys that the Lambda function has sucessfully fulfilled the intent.
	//
	//     *
	// ReadyForFulfillment - Conveys that the client has to fulfill the intent.
	DialogState types.DialogState
	// The audio version of the message to convey to the user.
	AudioStream io.ReadCloser
	// The next message that should be presented to the user.
	Message *string
	// Content type as specified in the Accept HTTP header in the request.
	ContentType *string
	// If the dialogState is ElicitSlot, returns the name of the slot for which Amazon
	// Lex is eliciting a value.
	SlotToElicit *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ResolveEndpoint struct {
	Resolver EndpointResolver
	Options  ResolverOptions
}

type ResolveEndpointMiddlewareOptions interface {
	GetEndpointResolver() EndpointResolver
	GetEndpointOptions() ResolverOptions
}

type ResolverOptions = internalendpoints.Options