Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ActiveContext

type ActiveContext struct {

	// The name of the context.
	//
	// This member is required.
	Name *string

	// State variables for the current context. You can use these values as default
	// values for slots in subsequent events.
	//
	// This member is required.
	Parameters map[string]string

	// The length of time or number of turns that a context remains active.
	//
	// This member is required.
	TimeToLive *ActiveContextTimeToLive
}

    A context is a variable that contains information about the current state of the conversation between a user and Amazon Lex. Context can be set automatically by Amazon Lex when an intent is fulfilled, or it can be set at runtime using the PutContent, PutText, or PutSession operation.

    type ActiveContextTimeToLive

    type ActiveContextTimeToLive struct {
    
    	// The number of seconds that the context should be active after it is first sent
    	// in a PostContent or PostText response. You can set the value between 5 and
    	// 86,400 seconds (24 hours).
    	TimeToLiveInSeconds *int32
    
    	// The number of conversation turns that the context should be active. A
    	// conversation turn is one PostContent or PostText request and the corresponding
    	// response from Amazon Lex.
    	TurnsToLive *int32
    }

      The length of time or number of turns that a context remains active.

      type BadGatewayException

      type BadGatewayException struct {
      	Message *string
      }

        Either the Amazon Lex bot is still building, or one of the dependent services (Amazon Polly, AWS Lambda) failed with an internal service error.

        func (*BadGatewayException) Error

        func (e *BadGatewayException) Error() string

        func (*BadGatewayException) ErrorCode

        func (e *BadGatewayException) ErrorCode() string

        func (*BadGatewayException) ErrorFault

        func (e *BadGatewayException) ErrorFault() smithy.ErrorFault

        func (*BadGatewayException) ErrorMessage

        func (e *BadGatewayException) ErrorMessage() string

        type BadRequestException

        type BadRequestException struct {
        	Message *string
        }

          Request validation failed, there is no usable message in the context, or the bot build failed, is still in progress, or contains unbuilt changes.

          func (*BadRequestException) Error

          func (e *BadRequestException) Error() string

          func (*BadRequestException) ErrorCode

          func (e *BadRequestException) ErrorCode() string

          func (*BadRequestException) ErrorFault

          func (e *BadRequestException) ErrorFault() smithy.ErrorFault

          func (*BadRequestException) ErrorMessage

          func (e *BadRequestException) ErrorMessage() string

          type Button

          type Button struct {
          
          	// Text that is visible to the user on the button.
          	//
          	// This member is required.
          	Text *string
          
          	// The value sent to Amazon Lex when a user chooses the button. For example,
          	// consider button text "NYC." When the user chooses the button, the value sent can
          	// be "New York City."
          	//
          	// This member is required.
          	Value *string
          }

            Represents an option to be shown on the client platform (Facebook, Slack, etc.)

            type ConfirmationStatus

            type ConfirmationStatus string
            const (
            	ConfirmationStatusNone      ConfirmationStatus = "None"
            	ConfirmationStatusConfirmed ConfirmationStatus = "Confirmed"
            	ConfirmationStatusDenied    ConfirmationStatus = "Denied"
            )

              Enum values for ConfirmationStatus

              func (ConfirmationStatus) Values

                Values returns all known values for ConfirmationStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                type ConflictException

                type ConflictException struct {
                	Message *string
                }

                  Two clients are using the same AWS account, Amazon Lex bot, and user ID.

                  func (*ConflictException) Error

                  func (e *ConflictException) Error() string

                  func (*ConflictException) ErrorCode

                  func (e *ConflictException) ErrorCode() string

                  func (*ConflictException) ErrorFault

                  func (e *ConflictException) ErrorFault() smithy.ErrorFault

                  func (*ConflictException) ErrorMessage

                  func (e *ConflictException) ErrorMessage() string

                  type ContentType

                  type ContentType string
                  const (
                  	ContentTypeGeneric ContentType = "application/vnd.amazonaws.card.generic"
                  )

                    Enum values for ContentType

                    func (ContentType) Values

                    func (ContentType) Values() []ContentType

                      Values returns all known values for ContentType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                      type DependencyFailedException

                      type DependencyFailedException struct {
                      	Message *string
                      }

                        One of the dependencies, such as AWS Lambda or Amazon Polly, threw an exception. For example,

                        * If Amazon Lex does not have sufficient permissions to call a Lambda function.

                        * If a Lambda function takes longer than 30 seconds to execute.

                        * If a fulfillment Lambda function returns a Delegate dialog action without removing any slot values.

                        func (*DependencyFailedException) Error

                        func (e *DependencyFailedException) Error() string

                        func (*DependencyFailedException) ErrorCode

                        func (e *DependencyFailedException) ErrorCode() string

                        func (*DependencyFailedException) ErrorFault

                        func (*DependencyFailedException) ErrorMessage

                        func (e *DependencyFailedException) ErrorMessage() string

                        type DialogAction

                        type DialogAction struct {
                        
                        	// The next action that the bot should take in its interaction with the user. The
                        	// possible values are:
                        	//
                        	// * ConfirmIntent - The next action is asking the user if
                        	// the intent is complete and ready to be fulfilled. This is a yes/no question such
                        	// as "Place the order?"
                        	//
                        	// * Close - Indicates that the there will not be a response
                        	// from the user. For example, the statement "Your order has been placed" does not
                        	// require a response.
                        	//
                        	// * Delegate - The next action is determined by Amazon
                        	// Lex.
                        	//
                        	// * ElicitIntent - The next action is to determine the intent that the user
                        	// wants to fulfill.
                        	//
                        	// * ElicitSlot - The next action is to elicit a slot value from
                        	// the user.
                        	//
                        	// This member is required.
                        	Type DialogActionType
                        
                        	// The fulfillment state of the intent. The possible values are:
                        	//
                        	// * Failed - The
                        	// Lambda function associated with the intent failed to fulfill the intent.
                        	//
                        	// *
                        	// Fulfilled - The intent has fulfilled by the Lambda function associated with the
                        	// intent.
                        	//
                        	// * ReadyForFulfillment - All of the information necessary for the intent
                        	// is present and the intent ready to be fulfilled by the client application.
                        	FulfillmentState FulfillmentState
                        
                        	// The name of the intent.
                        	IntentName *string
                        
                        	// The message that should be shown to the user. If you don't specify a message,
                        	// Amazon Lex will use the message configured for the intent.
                        	Message *string
                        
                        	// * 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. For more information, see Message Groups
                        	// (https://docs.aws.amazon.com/lex/latest/dg/howitworks-manage-prompts.html).
                        	MessageFormat MessageFormatType
                        
                        	// The name of the slot that should be elicited from the user.
                        	SlotToElicit *string
                        
                        	// Map of the slots that have been gathered and their values.
                        	Slots map[string]string
                        }

                          Describes the next action that the bot should take in its interaction with the user and provides information about the context in which the action takes place. Use the DialogAction data type to set the interaction to a specific state, or to return the interaction to a previous state.

                          type DialogActionType

                          type DialogActionType string
                          const (
                          	DialogActionTypeElicitIntent  DialogActionType = "ElicitIntent"
                          	DialogActionTypeConfirmIntent DialogActionType = "ConfirmIntent"
                          	DialogActionTypeElicitSlot    DialogActionType = "ElicitSlot"
                          	DialogActionTypeClose         DialogActionType = "Close"
                          	DialogActionTypeDelegate      DialogActionType = "Delegate"
                          )

                            Enum values for DialogActionType

                            func (DialogActionType) Values

                              Values returns all known values for DialogActionType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                              type DialogState

                              type DialogState string
                              const (
                              	DialogStateElicitIntent        DialogState = "ElicitIntent"
                              	DialogStateConfirmIntent       DialogState = "ConfirmIntent"
                              	DialogStateElicitSlot          DialogState = "ElicitSlot"
                              	DialogStateFulfilled           DialogState = "Fulfilled"
                              	DialogStateReadyForFulfillment DialogState = "ReadyForFulfillment"
                              	DialogStateFailed              DialogState = "Failed"
                              )

                                Enum values for DialogState

                                func (DialogState) Values

                                func (DialogState) Values() []DialogState

                                  Values returns all known values for DialogState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                  type FulfillmentState

                                  type FulfillmentState string
                                  const (
                                  	FulfillmentStateFulfilled           FulfillmentState = "Fulfilled"
                                  	FulfillmentStateFailed              FulfillmentState = "Failed"
                                  	FulfillmentStateReadyForFulfillment FulfillmentState = "ReadyForFulfillment"
                                  )

                                    Enum values for FulfillmentState

                                    func (FulfillmentState) Values

                                      Values returns all known values for FulfillmentState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                      type GenericAttachment

                                      type GenericAttachment struct {
                                      
                                      	// The URL of an attachment to the response card.
                                      	AttachmentLinkUrl *string
                                      
                                      	// The list of options to show to the user.
                                      	Buttons []Button
                                      
                                      	// The URL of an image that is displayed to the user.
                                      	ImageUrl *string
                                      
                                      	// The subtitle shown below the title.
                                      	SubTitle *string
                                      
                                      	// The title of the option.
                                      	Title *string
                                      }

                                        Represents an option rendered to the user when a prompt is shown. It could be an image, a button, a link, or text.

                                        type IntentConfidence

                                        type IntentConfidence struct {
                                        
                                        	// A score that indicates how confident Amazon Lex is that an intent satisfies the
                                        	// user's intent. Ranges between 0.00 and 1.00. Higher scores indicate higher
                                        	// confidence.
                                        	Score float64
                                        }

                                          Provides a score that indicates the confidence that Amazon Lex has that an intent is the one that satisfies the user's intent.

                                          type IntentSummary

                                          type IntentSummary struct {
                                          
                                          	// The next action that the bot should take in its interaction with the user. The
                                          	// possible values are:
                                          	//
                                          	// * ConfirmIntent - The next action is asking the user if
                                          	// the intent is complete and ready to be fulfilled. This is a yes/no question such
                                          	// as "Place the order?"
                                          	//
                                          	// * Close - Indicates that the there will not be a response
                                          	// from the user. For example, the statement "Your order has been placed" does not
                                          	// require a response.
                                          	//
                                          	// * ElicitIntent - The next action is to determine the intent
                                          	// that the user wants to fulfill.
                                          	//
                                          	// * ElicitSlot - The next action is to elicit a
                                          	// slot value from the user.
                                          	//
                                          	// This member is required.
                                          	DialogActionType DialogActionType
                                          
                                          	// A user-defined label that identifies a particular intent. You can use this label
                                          	// to return to a previous intent. Use the checkpointLabelFilter parameter of the
                                          	// GetSessionRequest operation to filter the intents returned by the operation to
                                          	// those with only the specified label.
                                          	CheckpointLabel *string
                                          
                                          	// The status of the intent after the user responds to the confirmation prompt. If
                                          	// the user confirms the intent, Amazon Lex sets this field to Confirmed. If the
                                          	// user denies the intent, Amazon Lex sets this value to Denied. The possible
                                          	// values are:
                                          	//
                                          	// * Confirmed - The user has responded "Yes" to the confirmation
                                          	// prompt, confirming that the intent is complete and that it is ready to be
                                          	// fulfilled.
                                          	//
                                          	// * Denied - The user has responded "No" to the confirmation
                                          	// prompt.
                                          	//
                                          	// * None - The user has never been prompted for confirmation; or, the
                                          	// user was prompted but did not confirm or deny the prompt.
                                          	ConfirmationStatus ConfirmationStatus
                                          
                                          	// The fulfillment state of the intent. The possible values are:
                                          	//
                                          	// * Failed - The
                                          	// Lambda function associated with the intent failed to fulfill the intent.
                                          	//
                                          	// *
                                          	// Fulfilled - The intent has fulfilled by the Lambda function associated with the
                                          	// intent.
                                          	//
                                          	// * ReadyForFulfillment - All of the information necessary for the intent
                                          	// is present and the intent ready to be fulfilled by the client application.
                                          	FulfillmentState FulfillmentState
                                          
                                          	// The name of the intent.
                                          	IntentName *string
                                          
                                          	// The next slot to elicit from the user. If there is not slot to elicit, the field
                                          	// is blank.
                                          	SlotToElicit *string
                                          
                                          	// Map of the slots that have been gathered and their values.
                                          	Slots map[string]string
                                          }

                                            Provides information about the state of an intent. You can use this information to get the current state of an intent so that you can process the intent, or so that you can return the intent to its previous state.

                                            type InternalFailureException

                                            type InternalFailureException struct {
                                            	Message *string
                                            }

                                              Internal service error. Retry the call.

                                              func (*InternalFailureException) Error

                                              func (e *InternalFailureException) Error() string

                                              func (*InternalFailureException) ErrorCode

                                              func (e *InternalFailureException) ErrorCode() string

                                              func (*InternalFailureException) ErrorFault

                                              func (e *InternalFailureException) ErrorFault() smithy.ErrorFault

                                              func (*InternalFailureException) ErrorMessage

                                              func (e *InternalFailureException) ErrorMessage() string

                                              type LimitExceededException

                                              type LimitExceededException struct {
                                              	Message *string
                                              
                                              	RetryAfterSeconds *string
                                              }

                                                Exceeded a limit.

                                                func (*LimitExceededException) Error

                                                func (e *LimitExceededException) Error() string

                                                func (*LimitExceededException) ErrorCode

                                                func (e *LimitExceededException) ErrorCode() string

                                                func (*LimitExceededException) ErrorFault

                                                func (e *LimitExceededException) ErrorFault() smithy.ErrorFault

                                                func (*LimitExceededException) ErrorMessage

                                                func (e *LimitExceededException) ErrorMessage() string

                                                type LoopDetectedException

                                                type LoopDetectedException struct {
                                                	Message *string
                                                }

                                                  This exception is not used.

                                                  func (*LoopDetectedException) Error

                                                  func (e *LoopDetectedException) Error() string

                                                  func (*LoopDetectedException) ErrorCode

                                                  func (e *LoopDetectedException) ErrorCode() string

                                                  func (*LoopDetectedException) ErrorFault

                                                  func (e *LoopDetectedException) ErrorFault() smithy.ErrorFault

                                                  func (*LoopDetectedException) ErrorMessage

                                                  func (e *LoopDetectedException) ErrorMessage() string

                                                  type MessageFormatType

                                                  type MessageFormatType string
                                                  const (
                                                  	MessageFormatTypePlainText     MessageFormatType = "PlainText"
                                                  	MessageFormatTypeCustomPayload MessageFormatType = "CustomPayload"
                                                  	MessageFormatTypeSsml          MessageFormatType = "SSML"
                                                  	MessageFormatTypeComposite     MessageFormatType = "Composite"
                                                  )

                                                    Enum values for MessageFormatType

                                                    func (MessageFormatType) Values

                                                      Values returns all known values for MessageFormatType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                      type NotAcceptableException

                                                      type NotAcceptableException struct {
                                                      	Message *string
                                                      }

                                                        The accept header in the request does not have a valid value.

                                                        func (*NotAcceptableException) Error

                                                        func (e *NotAcceptableException) Error() string

                                                        func (*NotAcceptableException) ErrorCode

                                                        func (e *NotAcceptableException) ErrorCode() string

                                                        func (*NotAcceptableException) ErrorFault

                                                        func (e *NotAcceptableException) ErrorFault() smithy.ErrorFault

                                                        func (*NotAcceptableException) ErrorMessage

                                                        func (e *NotAcceptableException) ErrorMessage() string

                                                        type NotFoundException

                                                        type NotFoundException struct {
                                                        	Message *string
                                                        }

                                                          The resource (such as the Amazon Lex bot or an alias) that is referred to is not found.

                                                          func (*NotFoundException) Error

                                                          func (e *NotFoundException) Error() string

                                                          func (*NotFoundException) ErrorCode

                                                          func (e *NotFoundException) ErrorCode() string

                                                          func (*NotFoundException) ErrorFault

                                                          func (e *NotFoundException) ErrorFault() smithy.ErrorFault

                                                          func (*NotFoundException) ErrorMessage

                                                          func (e *NotFoundException) ErrorMessage() string

                                                          type PredictedIntent

                                                          type PredictedIntent struct {
                                                          
                                                          	// The name of the intent that Amazon Lex suggests satisfies the user's intent.
                                                          	IntentName *string
                                                          
                                                          	// Indicates how confident Amazon Lex is that an intent satisfies the user's
                                                          	// intent.
                                                          	NluIntentConfidence *IntentConfidence
                                                          
                                                          	// The slot and slot values associated with the predicted intent.
                                                          	Slots map[string]string
                                                          }

                                                            An intent that Amazon Lex suggests satisfies the user's intent. Includes the name of the intent, the confidence that Amazon Lex has that the user's intent is satisfied, and the slots defined for the intent.

                                                            type RequestTimeoutException

                                                            type RequestTimeoutException struct {
                                                            	Message *string
                                                            }

                                                              The input speech is too long.

                                                              func (*RequestTimeoutException) Error

                                                              func (e *RequestTimeoutException) Error() string

                                                              func (*RequestTimeoutException) ErrorCode

                                                              func (e *RequestTimeoutException) ErrorCode() string

                                                              func (*RequestTimeoutException) ErrorFault

                                                              func (e *RequestTimeoutException) ErrorFault() smithy.ErrorFault

                                                              func (*RequestTimeoutException) ErrorMessage

                                                              func (e *RequestTimeoutException) ErrorMessage() string

                                                              type ResponseCard

                                                              type ResponseCard struct {
                                                              
                                                              	// The content type of the response.
                                                              	ContentType ContentType
                                                              
                                                              	// An array of attachment objects representing options.
                                                              	GenericAttachments []GenericAttachment
                                                              
                                                              	// The version of the response card format.
                                                              	Version *string
                                                              }

                                                                If you configure a response card when creating your bots, Amazon Lex substitutes the session attributes and slot values that are available, and then returns it. The response card can also come from a Lambda function ( dialogCodeHook and fulfillmentActivity on an intent).

                                                                type SentimentResponse

                                                                type SentimentResponse struct {
                                                                
                                                                	// The inferred sentiment that Amazon Comprehend has the highest confidence in.
                                                                	SentimentLabel *string
                                                                
                                                                	// The likelihood that the sentiment was correctly inferred.
                                                                	SentimentScore *string
                                                                }

                                                                  The sentiment expressed in an utterance. When the bot is configured to send utterances to Amazon Comprehend for sentiment analysis, this field structure contains the result of the analysis.

                                                                  type UnsupportedMediaTypeException

                                                                  type UnsupportedMediaTypeException struct {
                                                                  	Message *string
                                                                  }

                                                                    The Content-Type header (PostContent API) has an invalid value.

                                                                    func (*UnsupportedMediaTypeException) Error

                                                                    func (*UnsupportedMediaTypeException) ErrorCode

                                                                    func (e *UnsupportedMediaTypeException) ErrorCode() string

                                                                    func (*UnsupportedMediaTypeException) ErrorFault

                                                                    func (*UnsupportedMediaTypeException) ErrorMessage

                                                                    func (e *UnsupportedMediaTypeException) ErrorMessage() string