From 28875d2cb0eff199fd567c5bb284ef06cfa36b7c Mon Sep 17 00:00:00 2001 From: Jason Del Ponte Date: Fri, 3 Apr 2020 13:22:25 -0700 Subject: [PATCH] Add hand written smithy prototype iterations using lex runtime --- .../lexruntimeservice/api_client.go | 84 +++ .../lexruntimeservice/api_doc.go | 38 ++ .../lexruntimeservice/api_enums.go | 115 ++++ .../lexruntimeservice/api_errors.go | 84 +++ .../lexruntimeservice/api_op_DeleteSession.go | 203 +++++++ .../lexruntimeservice/api_op_GetSession.go | 240 ++++++++ .../lexruntimeservice/api_op_PostContent.go | 540 ++++++++++++++++++ .../lexruntimeservice/api_op_PostText.go | 463 +++++++++++++++ .../lexruntimeservice/api_op_PutSession.go | 391 +++++++++++++ .../lexruntimeservice/api_types.go | 489 ++++++++++++++++ .../lexruntimeserviceiface/interface.go | 75 +++ 11 files changed, 2722 insertions(+) create mode 100644 service/smithyprototype/lexruntimeservice/api_client.go create mode 100644 service/smithyprototype/lexruntimeservice/api_doc.go create mode 100644 service/smithyprototype/lexruntimeservice/api_enums.go create mode 100644 service/smithyprototype/lexruntimeservice/api_errors.go create mode 100644 service/smithyprototype/lexruntimeservice/api_op_DeleteSession.go create mode 100644 service/smithyprototype/lexruntimeservice/api_op_GetSession.go create mode 100644 service/smithyprototype/lexruntimeservice/api_op_PostContent.go create mode 100644 service/smithyprototype/lexruntimeservice/api_op_PostText.go create mode 100644 service/smithyprototype/lexruntimeservice/api_op_PutSession.go create mode 100644 service/smithyprototype/lexruntimeservice/api_types.go create mode 100644 service/smithyprototype/lexruntimeservice/lexruntimeserviceiface/interface.go diff --git a/service/smithyprototype/lexruntimeservice/api_client.go b/service/smithyprototype/lexruntimeservice/api_client.go new file mode 100644 index 00000000000..0ce8ec94417 --- /dev/null +++ b/service/smithyprototype/lexruntimeservice/api_client.go @@ -0,0 +1,84 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +package lexruntimeservice + +import ( + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/retry" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/private/protocol/restjson" +) + +// Client provides the API operation methods for making requests to +// Amazon Lex Runtime Service. See this package's package overview docs +// for details on the service. +// +// The client's methods are safe to use concurrently. It is not safe to +// modify mutate any of the struct's properties though. +type Client struct { + *aws.Client +} + +// Used for custom client initialization logic +var initClient func(*Client) + +// Used for custom request initialization logic +var initRequest func(*Client, *aws.Request) + +const ( + ServiceName = "Amazon Lex Runtime Service" // Service's name + ServiceID = "LexRuntimeService" // Service's identifier + EndpointsID = "runtime.lex" // Service's Endpoint identifier +) + +// New creates a new instance of the client from the provided Config. +// +// Example: +// // Create a client from just a config. +// svc := lexruntimeservice.New(myConfig) +func New(config aws.Config) *Client { + svc := &Client{ + Client: aws.NewClient( + config, + aws.Metadata{ + ServiceName: ServiceName, + ServiceID: ServiceID, + EndpointsID: EndpointsID, + SigningName: "lex", + SigningRegion: config.Region, + APIVersion: "2016-11-28", + }, + ), + } + + if config.Retryer == nil { + svc.Retryer = retry.NewStandard() + } + + // Handlers + svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) + svc.Handlers.Build.PushBackNamed(restjson.BuildHandler) + svc.Handlers.Unmarshal.PushBackNamed(restjson.UnmarshalHandler) + svc.Handlers.UnmarshalMeta.PushBackNamed(restjson.UnmarshalMetaHandler) + svc.Handlers.UnmarshalError.PushBackNamed(restjson.UnmarshalErrorHandler) + + // Run custom client initialization if present + if initClient != nil { + initClient(svc) + } + + return svc +} + +// newRequest creates a new request for a client operation and runs any +// custom request initialization. +func (c *Client) newRequest(op *aws.Operation, params, data interface{}) *aws.Request { + req := c.NewRequest(op, params, data) + + // Run custom request initialization if present + if initRequest != nil { + initRequest(c, req) + } + + return req +} diff --git a/service/smithyprototype/lexruntimeservice/api_doc.go b/service/smithyprototype/lexruntimeservice/api_doc.go new file mode 100644 index 00000000000..38a65dc6fff --- /dev/null +++ b/service/smithyprototype/lexruntimeservice/api_doc.go @@ -0,0 +1,38 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +// Package lexruntimeservice provides the client and types for making API +// requests to Amazon Lex Runtime Service. +// +// Amazon Lex provides both build and runtime endpoints. Each endpoint provides +// a set of operations (API). Your conversational bot uses the runtime API to +// understand user utterances (user input text or voice). For example, suppose +// a user says "I want pizza", your bot sends this input to Amazon Lex using +// the runtime API. Amazon Lex recognizes that the user request is for the OrderPizza +// intent (one of the intents defined in the bot). Then Amazon Lex engages in +// user conversation on behalf of the bot to elicit required information (slot +// values, such as pizza size and crust type), and then performs fulfillment +// activity (that you configured when you created the bot). You use the build-time +// API to create and manage your Amazon Lex bot. For a list of build-time operations, +// see the build-time API, . +// +// See https://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28 for more information on this service. +// +// See lexruntimeservice package documentation for more information. +// https://docs.aws.amazon.com/sdk-for-go/api/service/lexruntimeservice/ +// +// Using the Client +// +// To use Amazon Lex Runtime Service with the SDK use the New function to create +// a new service client. With that client you can make API requests to the service. +// These clients are safe to use concurrently. +// +// See the SDK's documentation for more information on how to use the SDK. +// https://docs.aws.amazon.com/sdk-for-go/api/ +// +// See aws.Config documentation for more information on configuring SDK clients. +// https://docs.aws.amazon.com/sdk-for-go/api/aws/#Config +// +// See the Amazon Lex Runtime Service client for more information on +// creating client for this service. +// https://docs.aws.amazon.com/sdk-for-go/api/service/lexruntimeservice/#New +package lexruntimeservice diff --git a/service/smithyprototype/lexruntimeservice/api_enums.go b/service/smithyprototype/lexruntimeservice/api_enums.go new file mode 100644 index 00000000000..f7b66e31dec --- /dev/null +++ b/service/smithyprototype/lexruntimeservice/api_enums.go @@ -0,0 +1,115 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +package lexruntimeservice + +type ConfirmationStatus string + +// Enum values for ConfirmationStatus +const ( + ConfirmationStatusNone ConfirmationStatus = "None" + ConfirmationStatusConfirmed ConfirmationStatus = "Confirmed" + ConfirmationStatusDenied ConfirmationStatus = "Denied" +) + +func (enum ConfirmationStatus) MarshalValue() (string, error) { + return string(enum), nil +} + +func (enum ConfirmationStatus) MarshalValueBuf(b []byte) ([]byte, error) { + b = b[0:0] + return append(b, enum...), nil +} + +type ContentType string + +// Enum values for ContentType +const ( + ContentTypeApplicationVndAmazonawsCardGeneric ContentType = "application/vnd.amazonaws.card.generic" +) + +func (enum ContentType) MarshalValue() (string, error) { + return string(enum), nil +} + +func (enum ContentType) MarshalValueBuf(b []byte) ([]byte, error) { + b = b[0:0] + return append(b, enum...), nil +} + +type DialogActionType string + +// Enum values for DialogActionType +const ( + DialogActionTypeElicitIntent DialogActionType = "ElicitIntent" + DialogActionTypeConfirmIntent DialogActionType = "ConfirmIntent" + DialogActionTypeElicitSlot DialogActionType = "ElicitSlot" + DialogActionTypeClose DialogActionType = "Close" + DialogActionTypeDelegate DialogActionType = "Delegate" +) + +func (enum DialogActionType) MarshalValue() (string, error) { + return string(enum), nil +} + +func (enum DialogActionType) MarshalValueBuf(b []byte) ([]byte, error) { + b = b[0:0] + return append(b, enum...), nil +} + +type DialogState string + +// Enum values for DialogState +const ( + DialogStateElicitIntent DialogState = "ElicitIntent" + DialogStateConfirmIntent DialogState = "ConfirmIntent" + DialogStateElicitSlot DialogState = "ElicitSlot" + DialogStateFulfilled DialogState = "Fulfilled" + DialogStateReadyForFulfillment DialogState = "ReadyForFulfillment" + DialogStateFailed DialogState = "Failed" +) + +func (enum DialogState) MarshalValue() (string, error) { + return string(enum), nil +} + +func (enum DialogState) MarshalValueBuf(b []byte) ([]byte, error) { + b = b[0:0] + return append(b, enum...), nil +} + +type FulfillmentState string + +// Enum values for FulfillmentState +const ( + FulfillmentStateFulfilled FulfillmentState = "Fulfilled" + FulfillmentStateFailed FulfillmentState = "Failed" + FulfillmentStateReadyForFulfillment FulfillmentState = "ReadyForFulfillment" +) + +func (enum FulfillmentState) MarshalValue() (string, error) { + return string(enum), nil +} + +func (enum FulfillmentState) MarshalValueBuf(b []byte) ([]byte, error) { + b = b[0:0] + return append(b, enum...), nil +} + +type MessageFormatType string + +// Enum values for MessageFormatType +const ( + MessageFormatTypePlainText MessageFormatType = "PlainText" + MessageFormatTypeCustomPayload MessageFormatType = "CustomPayload" + MessageFormatTypeSsml MessageFormatType = "SSML" + MessageFormatTypeComposite MessageFormatType = "Composite" +) + +func (enum MessageFormatType) MarshalValue() (string, error) { + return string(enum), nil +} + +func (enum MessageFormatType) MarshalValueBuf(b []byte) ([]byte, error) { + b = b[0:0] + return append(b, enum...), nil +} diff --git a/service/smithyprototype/lexruntimeservice/api_errors.go b/service/smithyprototype/lexruntimeservice/api_errors.go new file mode 100644 index 00000000000..8cb079f04bc --- /dev/null +++ b/service/smithyprototype/lexruntimeservice/api_errors.go @@ -0,0 +1,84 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +package lexruntimeservice + +const ( + + // ErrCodeBadGatewayException for service response error code + // "BadGatewayException". + // + // Either the Amazon Lex bot is still building, or one of the dependent services + // (Amazon Polly, AWS Lambda) failed with an internal service error. + ErrCodeBadGatewayException = "BadGatewayException" + + // ErrCodeBadRequestException for service response error code + // "BadRequestException". + // + // Request validation failed, there is no usable message in the context, or + // the bot build failed, is still in progress, or contains unbuilt changes. + ErrCodeBadRequestException = "BadRequestException" + + // ErrCodeConflictException for service response error code + // "ConflictException". + // + // Two clients are using the same AWS account, Amazon Lex bot, and user ID. + ErrCodeConflictException = "ConflictException" + + // ErrCodeDependencyFailedException for service response error code + // "DependencyFailedException". + // + // 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. + ErrCodeDependencyFailedException = "DependencyFailedException" + + // ErrCodeInternalFailureException for service response error code + // "InternalFailureException". + // + // Internal service error. Retry the call. + ErrCodeInternalFailureException = "InternalFailureException" + + // ErrCodeLimitExceededException for service response error code + // "LimitExceededException". + // + // Exceeded a limit. + ErrCodeLimitExceededException = "LimitExceededException" + + // ErrCodeLoopDetectedException for service response error code + // "LoopDetectedException". + // + // This exception is not used. + ErrCodeLoopDetectedException = "LoopDetectedException" + + // ErrCodeNotAcceptableException for service response error code + // "NotAcceptableException". + // + // The accept header in the request does not have a valid value. + ErrCodeNotAcceptableException = "NotAcceptableException" + + // ErrCodeNotFoundException for service response error code + // "NotFoundException". + // + // The resource (such as the Amazon Lex bot or an alias) that is referred to + // is not found. + ErrCodeNotFoundException = "NotFoundException" + + // ErrCodeRequestTimeoutException for service response error code + // "RequestTimeoutException". + // + // The input speech is too long. + ErrCodeRequestTimeoutException = "RequestTimeoutException" + + // ErrCodeUnsupportedMediaTypeException for service response error code + // "UnsupportedMediaTypeException". + // + // The Content-Type header (PostContent API) has an invalid value. + ErrCodeUnsupportedMediaTypeException = "UnsupportedMediaTypeException" +) diff --git a/service/smithyprototype/lexruntimeservice/api_op_DeleteSession.go b/service/smithyprototype/lexruntimeservice/api_op_DeleteSession.go new file mode 100644 index 00000000000..6adbe986c63 --- /dev/null +++ b/service/smithyprototype/lexruntimeservice/api_op_DeleteSession.go @@ -0,0 +1,203 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +package lexruntimeservice + +import ( + "context" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/internal/awsutil" + "github.com/aws/aws-sdk-go-v2/private/protocol" +) + +type DeleteSessionInput struct { + _ struct{} `type:"structure"` + + // The alias in use for the bot that contains the session data. + // + // BotAlias is a required field + BotAlias *string `location:"uri" locationName:"botAlias" type:"string" required:"true"` + + // The name of the bot that contains the session data. + // + // BotName is a required field + BotName *string `location:"uri" locationName:"botName" type:"string" required:"true"` + + // The identifier of the user associated with the session data. + // + // UserId is a required field + UserId *string `location:"uri" locationName:"userId" min:"2" type:"string" required:"true"` +} + +// String returns the string representation +func (s DeleteSessionInput) String() string { + return awsutil.Prettify(s) +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *DeleteSessionInput) Validate() error { + invalidParams := aws.ErrInvalidParams{Context: "DeleteSessionInput"} + + if s.BotAlias == nil { + invalidParams.Add(aws.NewErrParamRequired("BotAlias")) + } + + if s.BotName == nil { + invalidParams.Add(aws.NewErrParamRequired("BotName")) + } + + if s.UserId == nil { + invalidParams.Add(aws.NewErrParamRequired("UserId")) + } + if s.UserId != nil && len(*s.UserId) < 2 { + invalidParams.Add(aws.NewErrParamMinLen("UserId", 2)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// MarshalFields encodes the AWS API shape using the passed in protocol encoder. +func (s DeleteSessionInput) MarshalFields(e protocol.FieldEncoder) error { + e.SetValue(protocol.HeaderTarget, "Content-Type", protocol.StringValue("application/json"), protocol.Metadata{}) + + if s.BotAlias != nil { + v := *s.BotAlias + + metadata := protocol.Metadata{} + e.SetValue(protocol.PathTarget, "botAlias", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.BotName != nil { + v := *s.BotName + + metadata := protocol.Metadata{} + e.SetValue(protocol.PathTarget, "botName", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.UserId != nil { + v := *s.UserId + + metadata := protocol.Metadata{} + e.SetValue(protocol.PathTarget, "userId", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + return nil +} + +type DeleteSessionOutput struct { + _ struct{} `type:"structure"` + + // The alias in use for the bot associated with the session data. + BotAlias *string `locationName:"botAlias" type:"string"` + + // The name of the bot associated with the session data. + BotName *string `locationName:"botName" type:"string"` + + // The unique identifier for the session. + SessionId *string `locationName:"sessionId" type:"string"` + + // The ID of the client application user. + UserId *string `locationName:"userId" min:"2" type:"string"` +} + +// String returns the string representation +func (s DeleteSessionOutput) String() string { + return awsutil.Prettify(s) +} + +// MarshalFields encodes the AWS API shape using the passed in protocol encoder. +func (s DeleteSessionOutput) MarshalFields(e protocol.FieldEncoder) error { + if s.BotAlias != nil { + v := *s.BotAlias + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "botAlias", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.BotName != nil { + v := *s.BotName + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "botName", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.SessionId != nil { + v := *s.SessionId + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "sessionId", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.UserId != nil { + v := *s.UserId + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "userId", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + return nil +} + +const opDeleteSession = "DeleteSession" + +// DeleteSessionRequest returns a request value for making API operation for +// Amazon Lex Runtime Service. +// +// Removes session information for a specified bot, alias, and user ID. +// +// // Example sending a request using DeleteSessionRequest. +// req := client.DeleteSessionRequest(params) +// resp, err := req.Send(context.TODO()) +// if err == nil { +// fmt.Println(resp) +// } +// +// Please also see https://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/DeleteSession +func (c *Client) DeleteSessionRequest(input *DeleteSessionInput) DeleteSessionRequest { + op := &aws.Operation{ + Name: opDeleteSession, + HTTPMethod: "DELETE", + HTTPPath: "/bot/{botName}/alias/{botAlias}/user/{userId}/session", + } + + if input == nil { + input = &DeleteSessionInput{} + } + + req := c.newRequest(op, input, &DeleteSessionOutput{}) + return DeleteSessionRequest{Request: req, Input: input, Copy: c.DeleteSessionRequest} +} + +// DeleteSessionRequest is the request type for the +// DeleteSession API operation. +type DeleteSessionRequest struct { + *aws.Request + Input *DeleteSessionInput + Copy func(*DeleteSessionInput) DeleteSessionRequest +} + +// Send marshals and sends the DeleteSession API request. +func (r DeleteSessionRequest) Send(ctx context.Context) (*DeleteSessionResponse, error) { + r.Request.SetContext(ctx) + err := r.Request.Send() + if err != nil { + return nil, err + } + + resp := &DeleteSessionResponse{ + DeleteSessionOutput: r.Request.Data.(*DeleteSessionOutput), + response: &aws.Response{Request: r.Request}, + } + + return resp, nil +} + +// DeleteSessionResponse is the response type for the +// DeleteSession API operation. +type DeleteSessionResponse struct { + *DeleteSessionOutput + + response *aws.Response +} + +// SDKResponseMetdata returns the response metadata for the +// DeleteSession request. +func (r *DeleteSessionResponse) SDKResponseMetdata() *aws.Response { + return r.response +} diff --git a/service/smithyprototype/lexruntimeservice/api_op_GetSession.go b/service/smithyprototype/lexruntimeservice/api_op_GetSession.go new file mode 100644 index 00000000000..4a7b49656c6 --- /dev/null +++ b/service/smithyprototype/lexruntimeservice/api_op_GetSession.go @@ -0,0 +1,240 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +package lexruntimeservice + +import ( + "context" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/internal/awsutil" + "github.com/aws/aws-sdk-go-v2/private/protocol" +) + +type GetSessionInput struct { + _ struct{} `type:"structure"` + + // The alias in use for the bot that contains the session data. + // + // BotAlias is a required field + BotAlias *string `location:"uri" locationName:"botAlias" type:"string" required:"true"` + + // The name of the bot that contains the session data. + // + // BotName is a required field + BotName *string `location:"uri" locationName:"botName" type:"string" required:"true"` + + // 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 `location:"querystring" locationName:"checkpointLabelFilter" min:"1" type:"string"` + + // The ID of the client application user. Amazon Lex uses this to identify a + // user's conversation with your bot. + // + // UserId is a required field + UserId *string `location:"uri" locationName:"userId" min:"2" type:"string" required:"true"` +} + +// String returns the string representation +func (s GetSessionInput) String() string { + return awsutil.Prettify(s) +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *GetSessionInput) Validate() error { + invalidParams := aws.ErrInvalidParams{Context: "GetSessionInput"} + + if s.BotAlias == nil { + invalidParams.Add(aws.NewErrParamRequired("BotAlias")) + } + + if s.BotName == nil { + invalidParams.Add(aws.NewErrParamRequired("BotName")) + } + if s.CheckpointLabelFilter != nil && len(*s.CheckpointLabelFilter) < 1 { + invalidParams.Add(aws.NewErrParamMinLen("CheckpointLabelFilter", 1)) + } + + if s.UserId == nil { + invalidParams.Add(aws.NewErrParamRequired("UserId")) + } + if s.UserId != nil && len(*s.UserId) < 2 { + invalidParams.Add(aws.NewErrParamMinLen("UserId", 2)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// MarshalFields encodes the AWS API shape using the passed in protocol encoder. +func (s GetSessionInput) MarshalFields(e protocol.FieldEncoder) error { + e.SetValue(protocol.HeaderTarget, "Content-Type", protocol.StringValue("application/json"), protocol.Metadata{}) + + if s.BotAlias != nil { + v := *s.BotAlias + + metadata := protocol.Metadata{} + e.SetValue(protocol.PathTarget, "botAlias", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.BotName != nil { + v := *s.BotName + + metadata := protocol.Metadata{} + e.SetValue(protocol.PathTarget, "botName", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.UserId != nil { + v := *s.UserId + + metadata := protocol.Metadata{} + e.SetValue(protocol.PathTarget, "userId", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.CheckpointLabelFilter != nil { + v := *s.CheckpointLabelFilter + + metadata := protocol.Metadata{} + e.SetValue(protocol.QueryTarget, "checkpointLabelFilter", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + return nil +} + +type GetSessionOutput struct { + _ struct{} `type:"structure"` + + // Describes the current state of the bot. + DialogAction *DialogAction `locationName:"dialogAction" type:"structure"` + + // 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 []IntentSummary `locationName:"recentIntentSummaryView" type:"list"` + + // 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 `locationName:"sessionAttributes" type:"map" sensitive:"true"` + + // A unique identifier for the session. + SessionId *string `locationName:"sessionId" type:"string"` +} + +// String returns the string representation +func (s GetSessionOutput) String() string { + return awsutil.Prettify(s) +} + +// MarshalFields encodes the AWS API shape using the passed in protocol encoder. +func (s GetSessionOutput) MarshalFields(e protocol.FieldEncoder) error { + if s.DialogAction != nil { + v := s.DialogAction + + metadata := protocol.Metadata{} + e.SetFields(protocol.BodyTarget, "dialogAction", v, metadata) + } + if s.RecentIntentSummaryView != nil { + v := s.RecentIntentSummaryView + + metadata := protocol.Metadata{} + ls0 := e.List(protocol.BodyTarget, "recentIntentSummaryView", metadata) + ls0.Start() + for _, v1 := range v { + ls0.ListAddFields(v1) + } + ls0.End() + + } + if s.SessionAttributes != nil { + v := s.SessionAttributes + + metadata := protocol.Metadata{} + ms0 := e.Map(protocol.BodyTarget, "sessionAttributes", metadata) + ms0.Start() + for k1, v1 := range v { + ms0.MapSetValue(k1, protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v1)}) + } + ms0.End() + + } + if s.SessionId != nil { + v := *s.SessionId + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "sessionId", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + return nil +} + +const opGetSession = "GetSession" + +// GetSessionRequest returns a request value for making API operation for +// Amazon Lex Runtime Service. +// +// Returns session information for a specified bot, alias, and user ID. +// +// // Example sending a request using GetSessionRequest. +// req := client.GetSessionRequest(params) +// resp, err := req.Send(context.TODO()) +// if err == nil { +// fmt.Println(resp) +// } +// +// Please also see https://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/GetSession +func (c *Client) GetSessionRequest(input *GetSessionInput) GetSessionRequest { + op := &aws.Operation{ + Name: opGetSession, + HTTPMethod: "GET", + HTTPPath: "/bot/{botName}/alias/{botAlias}/user/{userId}/session/", + } + + if input == nil { + input = &GetSessionInput{} + } + + req := c.newRequest(op, input, &GetSessionOutput{}) + return GetSessionRequest{Request: req, Input: input, Copy: c.GetSessionRequest} +} + +// GetSessionRequest is the request type for the +// GetSession API operation. +type GetSessionRequest struct { + *aws.Request + Input *GetSessionInput + Copy func(*GetSessionInput) GetSessionRequest +} + +// Send marshals and sends the GetSession API request. +func (r GetSessionRequest) Send(ctx context.Context) (*GetSessionResponse, error) { + r.Request.SetContext(ctx) + err := r.Request.Send() + if err != nil { + return nil, err + } + + resp := &GetSessionResponse{ + GetSessionOutput: r.Request.Data.(*GetSessionOutput), + response: &aws.Response{Request: r.Request}, + } + + return resp, nil +} + +// GetSessionResponse is the response type for the +// GetSession API operation. +type GetSessionResponse struct { + *GetSessionOutput + + response *aws.Response +} + +// SDKResponseMetdata returns the response metadata for the +// GetSession request. +func (r *GetSessionResponse) SDKResponseMetdata() *aws.Response { + return r.response +} diff --git a/service/smithyprototype/lexruntimeservice/api_op_PostContent.go b/service/smithyprototype/lexruntimeservice/api_op_PostContent.go new file mode 100644 index 00000000000..4f6c3c46a1b --- /dev/null +++ b/service/smithyprototype/lexruntimeservice/api_op_PostContent.go @@ -0,0 +1,540 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +package lexruntimeservice + +import ( + "context" + "io" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/aws-sdk-go-v2/internal/awsutil" + "github.com/aws/aws-sdk-go-v2/private/protocol" +) + +type PostContentInput struct { + _ struct{} `type:"structure" payload:"InputStream"` + + // 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 `location:"header" locationName:"Accept" type:"string"` + + // Alias of the Amazon Lex bot. + // + // BotAlias is a required field + BotAlias *string `location:"uri" locationName:"botAlias" type:"string" required:"true"` + + // Name of the Amazon Lex bot. + // + // BotName is a required field + BotName *string `location:"uri" locationName:"botName" type:"string" required:"true"` + + // 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 is a required field + ContentType *string `location:"header" locationName:"Content-Type" type:"string" required:"true"` + + // 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. + // + // To use an non-seekable io.Reader for this request wrap the io.Reader with + // "aws.ReadSeekCloser". The SDK will not retry request errors for non-seekable + // readers. This will allow the SDK to send the reader's payload as chunked + // transfer encoding. + // + // InputStream is a required field + InputStream io.ReadSeeker `locationName:"inputStream" type:"blob" required:"true"` + + // 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). + RequestAttributes aws.JSONValue `location:"header" locationName:"x-amz-lex-request-attributes" type:"jsonvalue"` + + // 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). + SessionAttributes aws.JSONValue `location:"header" locationName:"x-amz-lex-session-attributes" type:"jsonvalue"` + + // 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 is a required field + UserId *string `location:"uri" locationName:"userId" min:"2" type:"string" required:"true"` +} + +// String returns the string representation +func (s PostContentInput) String() string { + return awsutil.Prettify(s) +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *PostContentInput) Validate() error { + invalidParams := aws.ErrInvalidParams{Context: "PostContentInput"} + + if s.BotAlias == nil { + invalidParams.Add(aws.NewErrParamRequired("BotAlias")) + } + + if s.BotName == nil { + invalidParams.Add(aws.NewErrParamRequired("BotName")) + } + + if s.ContentType == nil { + invalidParams.Add(aws.NewErrParamRequired("ContentType")) + } + + if s.InputStream == nil { + invalidParams.Add(aws.NewErrParamRequired("InputStream")) + } + + if s.UserId == nil { + invalidParams.Add(aws.NewErrParamRequired("UserId")) + } + if s.UserId != nil && len(*s.UserId) < 2 { + invalidParams.Add(aws.NewErrParamMinLen("UserId", 2)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// MarshalFields encodes the AWS API shape using the passed in protocol encoder. +func (s PostContentInput) MarshalFields(e protocol.FieldEncoder) error { + + if s.Accept != nil { + v := *s.Accept + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "Accept", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.ContentType != nil { + v := *s.ContentType + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "Content-Type", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.RequestAttributes != nil { + v := s.RequestAttributes + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-request-attributes", protocol.JSONValue{V: v, EscapeMode: protocol.Base64Escape}, metadata) + } + if s.SessionAttributes != nil { + v := s.SessionAttributes + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-session-attributes", protocol.JSONValue{V: v, EscapeMode: protocol.Base64Escape}, metadata) + } + if s.BotAlias != nil { + v := *s.BotAlias + + metadata := protocol.Metadata{} + e.SetValue(protocol.PathTarget, "botAlias", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.BotName != nil { + v := *s.BotName + + metadata := protocol.Metadata{} + e.SetValue(protocol.PathTarget, "botName", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.UserId != nil { + v := *s.UserId + + metadata := protocol.Metadata{} + e.SetValue(protocol.PathTarget, "userId", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.InputStream != nil { + v := s.InputStream + + metadata := protocol.Metadata{} + e.SetStream(protocol.PayloadTarget, "inputStream", protocol.ReadSeekerStream{V: v}, metadata) + } + return nil +} + +type PostContentOutput struct { + _ struct{} `type:"structure" payload:"AudioStream"` + + // 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 `locationName:"audioStream" type:"blob"` + + // Content type as specified in the Accept HTTP header in the request. + ContentType *string `location:"header" locationName:"Content-Type" type:"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 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 DialogState `location:"header" locationName:"x-amz-lex-dialog-state" type:"string" enum:"true"` + + // 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 `location:"header" locationName:"x-amz-lex-input-transcript" type:"string"` + + // Current user intent that Amazon Lex is aware of. + IntentName *string `location:"header" locationName:"x-amz-lex-intent-name" type:"string"` + + // 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 `location:"header" locationName:"x-amz-lex-message" min:"1" type:"string" sensitive:"true"` + + // 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 MessageFormatType `location:"header" locationName:"x-amz-lex-message-format" type:"string" enum:"true"` + + // 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 `location:"header" locationName:"x-amz-lex-sentiment" type:"string"` + + // Map of key/value pairs representing the session-specific context information. + SessionAttributes aws.JSONValue `location:"header" locationName:"x-amz-lex-session-attributes" type:"jsonvalue"` + + // The unique identifier for the session. + SessionId *string `location:"header" locationName:"x-amz-lex-session-id" type:"string"` + + // If the dialogState value is ElicitSlot, returns the name of the slot for + // which Amazon Lex is eliciting a value. + SlotToElicit *string `location:"header" locationName:"x-amz-lex-slot-to-elicit" type:"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. + Slots aws.JSONValue `location:"header" locationName:"x-amz-lex-slots" type:"jsonvalue"` +} + +// String returns the string representation +func (s PostContentOutput) String() string { + return awsutil.Prettify(s) +} + +// MarshalFields encodes the AWS API shape using the passed in protocol encoder. +func (s PostContentOutput) MarshalFields(e protocol.FieldEncoder) error { + if s.ContentType != nil { + v := *s.ContentType + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "Content-Type", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if len(s.DialogState) > 0 { + v := s.DialogState + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-dialog-state", protocol.QuotedValue{ValueMarshaler: v}, metadata) + } + if s.InputTranscript != nil { + v := *s.InputTranscript + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-input-transcript", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.IntentName != nil { + v := *s.IntentName + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-intent-name", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.Message != nil { + v := *s.Message + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-message", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if len(s.MessageFormat) > 0 { + v := s.MessageFormat + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-message-format", protocol.QuotedValue{ValueMarshaler: v}, metadata) + } + if s.SentimentResponse != nil { + v := *s.SentimentResponse + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-sentiment", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.SessionAttributes != nil { + v := s.SessionAttributes + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-session-attributes", protocol.JSONValue{V: v, EscapeMode: protocol.Base64Escape}, metadata) + } + if s.SessionId != nil { + v := *s.SessionId + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-session-id", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.SlotToElicit != nil { + v := *s.SlotToElicit + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-slot-to-elicit", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.Slots != nil { + v := s.Slots + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-slots", protocol.JSONValue{V: v, EscapeMode: protocol.Base64Escape}, metadata) + } + // Skipping AudioStream Output type's body not valid. + return nil +} + +const opPostContent = "PostContent" + +// PostContentRequest returns a request value for making API operation for +// Amazon Lex Runtime Service. +// +// 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 (https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html). +// +// // Example sending a request using PostContentRequest. +// req := client.PostContentRequest(params) +// resp, err := req.Send(context.TODO()) +// if err == nil { +// fmt.Println(resp) +// } +// +// Please also see https://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/PostContent +func (c *Client) PostContentRequest(input *PostContentInput) PostContentRequest { + op := &aws.Operation{ + Name: opPostContent, + HTTPMethod: "POST", + HTTPPath: "/bot/{botName}/alias/{botAlias}/user/{userId}/content", + } + + if input == nil { + input = &PostContentInput{} + } + + req := c.newRequest(op, input, &PostContentOutput{}) + req.Handlers.Sign.Remove(v4.SignRequestHandler) + handler := v4.BuildNamedHandler("v4.CustomSignerHandler", v4.WithUnsignedPayload) + req.Handlers.Sign.PushFrontNamed(handler) + return PostContentRequest{Request: req, Input: input, Copy: c.PostContentRequest} +} + +// PostContentRequest is the request type for the +// PostContent API operation. +type PostContentRequest struct { + *aws.Request + Input *PostContentInput + Copy func(*PostContentInput) PostContentRequest +} + +// Send marshals and sends the PostContent API request. +func (r PostContentRequest) Send(ctx context.Context) (*PostContentResponse, error) { + r.Request.SetContext(ctx) + err := r.Request.Send() + if err != nil { + return nil, err + } + + resp := &PostContentResponse{ + PostContentOutput: r.Request.Data.(*PostContentOutput), + response: &aws.Response{Request: r.Request}, + } + + return resp, nil +} + +// PostContentResponse is the response type for the +// PostContent API operation. +type PostContentResponse struct { + *PostContentOutput + + response *aws.Response +} + +// SDKResponseMetdata returns the response metadata for the +// PostContent request. +func (r *PostContentResponse) SDKResponseMetdata() *aws.Response { + return r.response +} diff --git a/service/smithyprototype/lexruntimeservice/api_op_PostText.go b/service/smithyprototype/lexruntimeservice/api_op_PostText.go new file mode 100644 index 00000000000..817f05f5507 --- /dev/null +++ b/service/smithyprototype/lexruntimeservice/api_op_PostText.go @@ -0,0 +1,463 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +package lexruntimeservice + +import ( + "context" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/internal/awsutil" + "github.com/aws/aws-sdk-go-v2/private/protocol" +) + +type PostTextInput struct { + _ struct{} `type:"structure"` + + // The alias of the Amazon Lex bot. + // + // BotAlias is a required field + BotAlias *string `location:"uri" locationName:"botAlias" type:"string" required:"true"` + + // The name of the Amazon Lex bot. + // + // BotName is a required field + BotName *string `location:"uri" locationName:"botName" type:"string" required:"true"` + + // The text that the user entered (Amazon Lex interprets this text). + // + // InputText is a required field + InputText *string `locationName:"inputText" min:"1" type:"string" required:"true" sensitive:"true"` + + // 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 `locationName:"requestAttributes" type:"map" sensitive:"true"` + + // 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 `locationName:"sessionAttributes" type:"map" sensitive:"true"` + + // 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 is a required field + UserId *string `location:"uri" locationName:"userId" min:"2" type:"string" required:"true"` +} + +// String returns the string representation +func (s PostTextInput) String() string { + return awsutil.Prettify(s) +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *PostTextInput) Validate() error { + invalidParams := aws.ErrInvalidParams{Context: "PostTextInput"} + + if s.BotAlias == nil { + invalidParams.Add(aws.NewErrParamRequired("BotAlias")) + } + + if s.BotName == nil { + invalidParams.Add(aws.NewErrParamRequired("BotName")) + } + + if s.InputText == nil { + invalidParams.Add(aws.NewErrParamRequired("InputText")) + } + if s.InputText != nil && len(*s.InputText) < 1 { + invalidParams.Add(aws.NewErrParamMinLen("InputText", 1)) + } + + if s.UserId == nil { + invalidParams.Add(aws.NewErrParamRequired("UserId")) + } + if s.UserId != nil && len(*s.UserId) < 2 { + invalidParams.Add(aws.NewErrParamMinLen("UserId", 2)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// MarshalFields encodes the AWS API shape using the passed in protocol encoder. +func (s PostTextInput) MarshalFields(e protocol.FieldEncoder) error { + e.SetValue(protocol.HeaderTarget, "Content-Type", protocol.StringValue("application/json"), protocol.Metadata{}) + + if s.InputText != nil { + v := *s.InputText + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "inputText", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.RequestAttributes != nil { + v := s.RequestAttributes + + metadata := protocol.Metadata{} + ms0 := e.Map(protocol.BodyTarget, "requestAttributes", metadata) + ms0.Start() + for k1, v1 := range v { + ms0.MapSetValue(k1, protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v1)}) + } + ms0.End() + + } + if s.SessionAttributes != nil { + v := s.SessionAttributes + + metadata := protocol.Metadata{} + ms0 := e.Map(protocol.BodyTarget, "sessionAttributes", metadata) + ms0.Start() + for k1, v1 := range v { + ms0.MapSetValue(k1, protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v1)}) + } + ms0.End() + + } + if s.BotAlias != nil { + v := *s.BotAlias + + metadata := protocol.Metadata{} + e.SetValue(protocol.PathTarget, "botAlias", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.BotName != nil { + v := *s.BotName + + metadata := protocol.Metadata{} + e.SetValue(protocol.PathTarget, "botName", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.UserId != nil { + v := *s.UserId + + metadata := protocol.Metadata{} + e.SetValue(protocol.PathTarget, "userId", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + return nil +} + +type PostTextOutput struct { + _ struct{} `type:"structure"` + + // 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. + // + // * ReadyForFulfillment - Conveys that the client has to fulfill the intent. + // + // * Failed - Conveys that the conversation with the user failed. 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. + DialogState DialogState `locationName:"dialogState" type:"string" enum:"true"` + + // The current user intent that Amazon Lex is aware of. + IntentName *string `locationName:"intentName" type:"string"` + + // 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 `locationName:"message" min:"1" type:"string" sensitive:"true"` + + // 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 MessageFormatType `locationName:"messageFormat" type:"string" enum:"true"` + + // 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 *ResponseCard `locationName:"responseCard" type:"structure"` + + // 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 *SentimentResponse `locationName:"sentimentResponse" type:"structure"` + + // A map of key-value pairs representing the session-specific context information. + SessionAttributes map[string]string `locationName:"sessionAttributes" type:"map" sensitive:"true"` + + // A unique identifier for the session. + SessionId *string `locationName:"sessionId" type:"string"` + + // If the dialogState value is ElicitSlot, returns the name of the slot for + // which Amazon Lex is eliciting a value. + SlotToElicit *string `locationName:"slotToElicit" type:"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 `locationName:"slots" type:"map" sensitive:"true"` +} + +// String returns the string representation +func (s PostTextOutput) String() string { + return awsutil.Prettify(s) +} + +// MarshalFields encodes the AWS API shape using the passed in protocol encoder. +func (s PostTextOutput) MarshalFields(e protocol.FieldEncoder) error { + if len(s.DialogState) > 0 { + v := s.DialogState + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "dialogState", protocol.QuotedValue{ValueMarshaler: v}, metadata) + } + if s.IntentName != nil { + v := *s.IntentName + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "intentName", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.Message != nil { + v := *s.Message + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "message", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if len(s.MessageFormat) > 0 { + v := s.MessageFormat + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "messageFormat", protocol.QuotedValue{ValueMarshaler: v}, metadata) + } + if s.ResponseCard != nil { + v := s.ResponseCard + + metadata := protocol.Metadata{} + e.SetFields(protocol.BodyTarget, "responseCard", v, metadata) + } + if s.SentimentResponse != nil { + v := s.SentimentResponse + + metadata := protocol.Metadata{} + e.SetFields(protocol.BodyTarget, "sentimentResponse", v, metadata) + } + if s.SessionAttributes != nil { + v := s.SessionAttributes + + metadata := protocol.Metadata{} + ms0 := e.Map(protocol.BodyTarget, "sessionAttributes", metadata) + ms0.Start() + for k1, v1 := range v { + ms0.MapSetValue(k1, protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v1)}) + } + ms0.End() + + } + if s.SessionId != nil { + v := *s.SessionId + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "sessionId", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.SlotToElicit != nil { + v := *s.SlotToElicit + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "slotToElicit", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.Slots != nil { + v := s.Slots + + metadata := protocol.Metadata{} + ms0 := e.Map(protocol.BodyTarget, "slots", metadata) + ms0.Start() + for k1, v1 := range v { + ms0.MapSetValue(k1, protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v1)}) + } + ms0.End() + + } + return nil +} + +const opPostText = "PostText" + +// PostTextRequest returns a request value for making API operation for +// Amazon Lex Runtime Service. +// +// 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 (https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html). +// +// // Example sending a request using PostTextRequest. +// req := client.PostTextRequest(params) +// resp, err := req.Send(context.TODO()) +// if err == nil { +// fmt.Println(resp) +// } +// +// Please also see https://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/PostText +func (c *Client) PostTextRequest(input *PostTextInput) PostTextRequest { + op := &aws.Operation{ + Name: opPostText, + HTTPMethod: "POST", + HTTPPath: "/bot/{botName}/alias/{botAlias}/user/{userId}/text", + } + + if input == nil { + input = &PostTextInput{} + } + + req := c.newRequest(op, input, &PostTextOutput{}) + return PostTextRequest{Request: req, Input: input, Copy: c.PostTextRequest} +} + +// PostTextRequest is the request type for the +// PostText API operation. +type PostTextRequest struct { + *aws.Request + Input *PostTextInput + Copy func(*PostTextInput) PostTextRequest +} + +// Send marshals and sends the PostText API request. +func (r PostTextRequest) Send(ctx context.Context) (*PostTextResponse, error) { + r.Request.SetContext(ctx) + err := r.Request.Send() + if err != nil { + return nil, err + } + + resp := &PostTextResponse{ + PostTextOutput: r.Request.Data.(*PostTextOutput), + response: &aws.Response{Request: r.Request}, + } + + return resp, nil +} + +// PostTextResponse is the response type for the +// PostText API operation. +type PostTextResponse struct { + *PostTextOutput + + response *aws.Response +} + +// SDKResponseMetdata returns the response metadata for the +// PostText request. +func (r *PostTextResponse) SDKResponseMetdata() *aws.Response { + return r.response +} diff --git a/service/smithyprototype/lexruntimeservice/api_op_PutSession.go b/service/smithyprototype/lexruntimeservice/api_op_PutSession.go new file mode 100644 index 00000000000..0718a545139 --- /dev/null +++ b/service/smithyprototype/lexruntimeservice/api_op_PutSession.go @@ -0,0 +1,391 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +package lexruntimeservice + +import ( + "context" + "fmt" + "io" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/internal/awsutil" + "github.com/aws/aws-sdk-go-v2/private/protocol" +) + +type PutSessionInput struct { + _ struct{} `type:"structure"` + + // 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 `location:"header" locationName:"Accept" type:"string"` + + // The alias in use for the bot that contains the session data. + // + // BotAlias is a required field + BotAlias *string `location:"uri" locationName:"botAlias" type:"string" required:"true"` + + // The name of the bot that contains the session data. + // + // BotName is a required field + BotName *string `location:"uri" locationName:"botName" type:"string" required:"true"` + + // Sets the next action that the bot should take to fulfill the conversation. + DialogAction *DialogAction `locationName:"dialogAction" type:"structure"` + + // 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 []IntentSummary `locationName:"recentIntentSummaryView" type:"list"` + + // 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 `locationName:"sessionAttributes" type:"map" sensitive:"true"` + + // The ID of the client application user. Amazon Lex uses this to identify a + // user's conversation with your bot. + // + // UserId is a required field + UserId *string `location:"uri" locationName:"userId" min:"2" type:"string" required:"true"` +} + +// String returns the string representation +func (s PutSessionInput) String() string { + return awsutil.Prettify(s) +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *PutSessionInput) Validate() error { + invalidParams := aws.ErrInvalidParams{Context: "PutSessionInput"} + + if s.BotAlias == nil { + invalidParams.Add(aws.NewErrParamRequired("BotAlias")) + } + + if s.BotName == nil { + invalidParams.Add(aws.NewErrParamRequired("BotName")) + } + + if s.UserId == nil { + invalidParams.Add(aws.NewErrParamRequired("UserId")) + } + if s.UserId != nil && len(*s.UserId) < 2 { + invalidParams.Add(aws.NewErrParamMinLen("UserId", 2)) + } + if s.DialogAction != nil { + if err := s.DialogAction.Validate(); err != nil { + invalidParams.AddNested("DialogAction", err.(aws.ErrInvalidParams)) + } + } + if s.RecentIntentSummaryView != nil { + for i, v := range s.RecentIntentSummaryView { + if err := v.Validate(); err != nil { + invalidParams.AddNested(fmt.Sprintf("%s[%v]", "RecentIntentSummaryView", i), err.(aws.ErrInvalidParams)) + } + } + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// MarshalFields encodes the AWS API shape using the passed in protocol encoder. +func (s PutSessionInput) MarshalFields(e protocol.FieldEncoder) error { + e.SetValue(protocol.HeaderTarget, "Content-Type", protocol.StringValue("application/json"), protocol.Metadata{}) + + if s.DialogAction != nil { + v := s.DialogAction + + metadata := protocol.Metadata{} + e.SetFields(protocol.BodyTarget, "dialogAction", v, metadata) + } + if s.RecentIntentSummaryView != nil { + v := s.RecentIntentSummaryView + + metadata := protocol.Metadata{} + ls0 := e.List(protocol.BodyTarget, "recentIntentSummaryView", metadata) + ls0.Start() + for _, v1 := range v { + ls0.ListAddFields(v1) + } + ls0.End() + + } + if s.SessionAttributes != nil { + v := s.SessionAttributes + + metadata := protocol.Metadata{} + ms0 := e.Map(protocol.BodyTarget, "sessionAttributes", metadata) + ms0.Start() + for k1, v1 := range v { + ms0.MapSetValue(k1, protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v1)}) + } + ms0.End() + + } + if s.Accept != nil { + v := *s.Accept + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "Accept", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.BotAlias != nil { + v := *s.BotAlias + + metadata := protocol.Metadata{} + e.SetValue(protocol.PathTarget, "botAlias", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.BotName != nil { + v := *s.BotName + + metadata := protocol.Metadata{} + e.SetValue(protocol.PathTarget, "botName", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.UserId != nil { + v := *s.UserId + + metadata := protocol.Metadata{} + e.SetValue(protocol.PathTarget, "userId", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + return nil +} + +type PutSessionOutput struct { + _ struct{} `type:"structure" payload:"AudioStream"` + + // The audio version of the message to convey to the user. + AudioStream io.ReadCloser `locationName:"audioStream" type:"blob"` + + // Content type as specified in the Accept HTTP header in the request. + ContentType *string `location:"header" locationName:"Content-Type" type:"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 DialogState `location:"header" locationName:"x-amz-lex-dialog-state" type:"string" enum:"true"` + + // The name of the current intent. + IntentName *string `location:"header" locationName:"x-amz-lex-intent-name" type:"string"` + + // The next message that should be presented to the user. + Message *string `location:"header" locationName:"x-amz-lex-message" min:"1" type:"string" sensitive:"true"` + + // 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 MessageFormatType `location:"header" locationName:"x-amz-lex-message-format" type:"string" enum:"true"` + + // Map of key/value pairs representing session-specific context information. + SessionAttributes aws.JSONValue `location:"header" locationName:"x-amz-lex-session-attributes" type:"jsonvalue"` + + // A unique identifier for the session. + SessionId *string `location:"header" locationName:"x-amz-lex-session-id" type:"string"` + + // If the dialogState is ElicitSlot, returns the name of the slot for which + // Amazon Lex is eliciting a value. + SlotToElicit *string `location:"header" locationName:"x-amz-lex-slot-to-elicit" type:"string"` + + // 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. + Slots aws.JSONValue `location:"header" locationName:"x-amz-lex-slots" type:"jsonvalue"` +} + +// String returns the string representation +func (s PutSessionOutput) String() string { + return awsutil.Prettify(s) +} + +// MarshalFields encodes the AWS API shape using the passed in protocol encoder. +func (s PutSessionOutput) MarshalFields(e protocol.FieldEncoder) error { + if s.ContentType != nil { + v := *s.ContentType + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "Content-Type", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if len(s.DialogState) > 0 { + v := s.DialogState + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-dialog-state", protocol.QuotedValue{ValueMarshaler: v}, metadata) + } + if s.IntentName != nil { + v := *s.IntentName + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-intent-name", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.Message != nil { + v := *s.Message + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-message", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if len(s.MessageFormat) > 0 { + v := s.MessageFormat + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-message-format", protocol.QuotedValue{ValueMarshaler: v}, metadata) + } + if s.SessionAttributes != nil { + v := s.SessionAttributes + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-session-attributes", protocol.JSONValue{V: v, EscapeMode: protocol.Base64Escape}, metadata) + } + if s.SessionId != nil { + v := *s.SessionId + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-session-id", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.SlotToElicit != nil { + v := *s.SlotToElicit + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-slot-to-elicit", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.Slots != nil { + v := s.Slots + + metadata := protocol.Metadata{} + e.SetValue(protocol.HeaderTarget, "x-amz-lex-slots", protocol.JSONValue{V: v, EscapeMode: protocol.Base64Escape}, metadata) + } + // Skipping AudioStream Output type's body not valid. + return nil +} + +const opPutSession = "PutSession" + +// PutSessionRequest returns a request value for making API operation for +// Amazon Lex Runtime Service. +// +// 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 (https://docs.aws.amazon.com/lex/latest/dg/how-session-api.html). +// +// // Example sending a request using PutSessionRequest. +// req := client.PutSessionRequest(params) +// resp, err := req.Send(context.TODO()) +// if err == nil { +// fmt.Println(resp) +// } +// +// Please also see https://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/PutSession +func (c *Client) PutSessionRequest(input *PutSessionInput) PutSessionRequest { + op := &aws.Operation{ + Name: opPutSession, + HTTPMethod: "POST", + HTTPPath: "/bot/{botName}/alias/{botAlias}/user/{userId}/session", + } + + if input == nil { + input = &PutSessionInput{} + } + + req := c.newRequest(op, input, &PutSessionOutput{}) + return PutSessionRequest{Request: req, Input: input, Copy: c.PutSessionRequest} +} + +// PutSessionRequest is the request type for the +// PutSession API operation. +type PutSessionRequest struct { + *aws.Request + Input *PutSessionInput + Copy func(*PutSessionInput) PutSessionRequest +} + +// Send marshals and sends the PutSession API request. +func (r PutSessionRequest) Send(ctx context.Context) (*PutSessionResponse, error) { + r.Request.SetContext(ctx) + err := r.Request.Send() + if err != nil { + return nil, err + } + + resp := &PutSessionResponse{ + PutSessionOutput: r.Request.Data.(*PutSessionOutput), + response: &aws.Response{Request: r.Request}, + } + + return resp, nil +} + +// PutSessionResponse is the response type for the +// PutSession API operation. +type PutSessionResponse struct { + *PutSessionOutput + + response *aws.Response +} + +// SDKResponseMetdata returns the response metadata for the +// PutSession request. +func (r *PutSessionResponse) SDKResponseMetdata() *aws.Response { + return r.response +} diff --git a/service/smithyprototype/lexruntimeservice/api_types.go b/service/smithyprototype/lexruntimeservice/api_types.go new file mode 100644 index 00000000000..d0574a4ab2f --- /dev/null +++ b/service/smithyprototype/lexruntimeservice/api_types.go @@ -0,0 +1,489 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +package lexruntimeservice + +import ( + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/internal/awsutil" + "github.com/aws/aws-sdk-go-v2/private/protocol" +) + +var _ aws.Config +var _ = awsutil.Prettify + +// Represents an option to be shown on the client platform (Facebook, Slack, +// etc.) +type Button struct { + _ struct{} `type:"structure"` + + // Text that is visible to the user on the button. + // + // Text is a required field + Text *string `locationName:"text" min:"1" type:"string" required:"true"` + + // 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." + // + // Value is a required field + Value *string `locationName:"value" min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s Button) String() string { + return awsutil.Prettify(s) +} + +// MarshalFields encodes the AWS API shape using the passed in protocol encoder. +func (s Button) MarshalFields(e protocol.FieldEncoder) error { + if s.Text != nil { + v := *s.Text + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "text", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.Value != nil { + v := *s.Value + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "value", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + return nil +} + +// 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 DialogAction struct { + _ struct{} `type:"structure"` + + // 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 `locationName:"fulfillmentState" type:"string" enum:"true"` + + // The name of the intent. + IntentName *string `locationName:"intentName" type:"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 `locationName:"message" min:"1" type:"string" sensitive:"true"` + + // * 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 `locationName:"messageFormat" type:"string" enum:"true"` + + // The name of the slot that should be elicited from the user. + SlotToElicit *string `locationName:"slotToElicit" type:"string"` + + // Map of the slots that have been gathered and their values. + Slots map[string]string `locationName:"slots" type:"map" sensitive:"true"` + + // 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. + // + // Type is a required field + Type DialogActionType `locationName:"type" type:"string" required:"true" enum:"true"` +} + +// String returns the string representation +func (s DialogAction) String() string { + return awsutil.Prettify(s) +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *DialogAction) Validate() error { + invalidParams := aws.ErrInvalidParams{Context: "DialogAction"} + if s.Message != nil && len(*s.Message) < 1 { + invalidParams.Add(aws.NewErrParamMinLen("Message", 1)) + } + if len(s.Type) == 0 { + invalidParams.Add(aws.NewErrParamRequired("Type")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// MarshalFields encodes the AWS API shape using the passed in protocol encoder. +func (s DialogAction) MarshalFields(e protocol.FieldEncoder) error { + if len(s.FulfillmentState) > 0 { + v := s.FulfillmentState + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "fulfillmentState", protocol.QuotedValue{ValueMarshaler: v}, metadata) + } + if s.IntentName != nil { + v := *s.IntentName + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "intentName", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.Message != nil { + v := *s.Message + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "message", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if len(s.MessageFormat) > 0 { + v := s.MessageFormat + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "messageFormat", protocol.QuotedValue{ValueMarshaler: v}, metadata) + } + if s.SlotToElicit != nil { + v := *s.SlotToElicit + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "slotToElicit", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.Slots != nil { + v := s.Slots + + metadata := protocol.Metadata{} + ms0 := e.Map(protocol.BodyTarget, "slots", metadata) + ms0.Start() + for k1, v1 := range v { + ms0.MapSetValue(k1, protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v1)}) + } + ms0.End() + + } + if len(s.Type) > 0 { + v := s.Type + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "type", protocol.QuotedValue{ValueMarshaler: v}, metadata) + } + return nil +} + +// Represents an option rendered to the user when a prompt is shown. It could +// be an image, a button, a link, or text. +type GenericAttachment struct { + _ struct{} `type:"structure"` + + // The URL of an attachment to the response card. + AttachmentLinkUrl *string `locationName:"attachmentLinkUrl" min:"1" type:"string"` + + // The list of options to show to the user. + Buttons []Button `locationName:"buttons" type:"list"` + + // The URL of an image that is displayed to the user. + ImageUrl *string `locationName:"imageUrl" min:"1" type:"string"` + + // The subtitle shown below the title. + SubTitle *string `locationName:"subTitle" min:"1" type:"string"` + + // The title of the option. + Title *string `locationName:"title" min:"1" type:"string"` +} + +// String returns the string representation +func (s GenericAttachment) String() string { + return awsutil.Prettify(s) +} + +// MarshalFields encodes the AWS API shape using the passed in protocol encoder. +func (s GenericAttachment) MarshalFields(e protocol.FieldEncoder) error { + if s.AttachmentLinkUrl != nil { + v := *s.AttachmentLinkUrl + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "attachmentLinkUrl", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.Buttons != nil { + v := s.Buttons + + metadata := protocol.Metadata{} + ls0 := e.List(protocol.BodyTarget, "buttons", metadata) + ls0.Start() + for _, v1 := range v { + ls0.ListAddFields(v1) + } + ls0.End() + + } + if s.ImageUrl != nil { + v := *s.ImageUrl + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "imageUrl", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.SubTitle != nil { + v := *s.SubTitle + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "subTitle", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.Title != nil { + v := *s.Title + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "title", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + return nil +} + +// 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 IntentSummary struct { + _ struct{} `type:"structure"` + + // 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 `locationName:"checkpointLabel" min:"1" type:"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 `locationName:"confirmationStatus" type:"string" enum:"true"` + + // 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. + // + // DialogActionType is a required field + DialogActionType DialogActionType `locationName:"dialogActionType" type:"string" required:"true" enum:"true"` + + // 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 `locationName:"fulfillmentState" type:"string" enum:"true"` + + // The name of the intent. + IntentName *string `locationName:"intentName" type:"string"` + + // The next slot to elicit from the user. If there is not slot to elicit, the + // field is blank. + SlotToElicit *string `locationName:"slotToElicit" type:"string"` + + // Map of the slots that have been gathered and their values. + Slots map[string]string `locationName:"slots" type:"map" sensitive:"true"` +} + +// String returns the string representation +func (s IntentSummary) String() string { + return awsutil.Prettify(s) +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *IntentSummary) Validate() error { + invalidParams := aws.ErrInvalidParams{Context: "IntentSummary"} + if s.CheckpointLabel != nil && len(*s.CheckpointLabel) < 1 { + invalidParams.Add(aws.NewErrParamMinLen("CheckpointLabel", 1)) + } + if len(s.DialogActionType) == 0 { + invalidParams.Add(aws.NewErrParamRequired("DialogActionType")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// MarshalFields encodes the AWS API shape using the passed in protocol encoder. +func (s IntentSummary) MarshalFields(e protocol.FieldEncoder) error { + if s.CheckpointLabel != nil { + v := *s.CheckpointLabel + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "checkpointLabel", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if len(s.ConfirmationStatus) > 0 { + v := s.ConfirmationStatus + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "confirmationStatus", protocol.QuotedValue{ValueMarshaler: v}, metadata) + } + if len(s.DialogActionType) > 0 { + v := s.DialogActionType + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "dialogActionType", protocol.QuotedValue{ValueMarshaler: v}, metadata) + } + if len(s.FulfillmentState) > 0 { + v := s.FulfillmentState + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "fulfillmentState", protocol.QuotedValue{ValueMarshaler: v}, metadata) + } + if s.IntentName != nil { + v := *s.IntentName + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "intentName", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.SlotToElicit != nil { + v := *s.SlotToElicit + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "slotToElicit", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.Slots != nil { + v := s.Slots + + metadata := protocol.Metadata{} + ms0 := e.Map(protocol.BodyTarget, "slots", metadata) + ms0.Start() + for k1, v1 := range v { + ms0.MapSetValue(k1, protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v1)}) + } + ms0.End() + + } + return nil +} + +// 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 ResponseCard struct { + _ struct{} `type:"structure"` + + // The content type of the response. + ContentType ContentType `locationName:"contentType" type:"string" enum:"true"` + + // An array of attachment objects representing options. + GenericAttachments []GenericAttachment `locationName:"genericAttachments" type:"list"` + + // The version of the response card format. + Version *string `locationName:"version" type:"string"` +} + +// String returns the string representation +func (s ResponseCard) String() string { + return awsutil.Prettify(s) +} + +// MarshalFields encodes the AWS API shape using the passed in protocol encoder. +func (s ResponseCard) MarshalFields(e protocol.FieldEncoder) error { + if len(s.ContentType) > 0 { + v := s.ContentType + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "contentType", protocol.QuotedValue{ValueMarshaler: v}, metadata) + } + if s.GenericAttachments != nil { + v := s.GenericAttachments + + metadata := protocol.Metadata{} + ls0 := e.List(protocol.BodyTarget, "genericAttachments", metadata) + ls0.Start() + for _, v1 := range v { + ls0.ListAddFields(v1) + } + ls0.End() + + } + if s.Version != nil { + v := *s.Version + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "version", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + return nil +} + +// 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 SentimentResponse struct { + _ struct{} `type:"structure"` + + // The inferred sentiment that Amazon Comprehend has the highest confidence + // in. + SentimentLabel *string `locationName:"sentimentLabel" type:"string"` + + // The likelihood that the sentiment was correctly inferred. + SentimentScore *string `locationName:"sentimentScore" type:"string"` +} + +// String returns the string representation +func (s SentimentResponse) String() string { + return awsutil.Prettify(s) +} + +// MarshalFields encodes the AWS API shape using the passed in protocol encoder. +func (s SentimentResponse) MarshalFields(e protocol.FieldEncoder) error { + if s.SentimentLabel != nil { + v := *s.SentimentLabel + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "sentimentLabel", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + if s.SentimentScore != nil { + v := *s.SentimentScore + + metadata := protocol.Metadata{} + e.SetValue(protocol.BodyTarget, "sentimentScore", protocol.QuotedValue{ValueMarshaler: protocol.StringValue(v)}, metadata) + } + return nil +} diff --git a/service/smithyprototype/lexruntimeservice/lexruntimeserviceiface/interface.go b/service/smithyprototype/lexruntimeservice/lexruntimeserviceiface/interface.go new file mode 100644 index 00000000000..00bedc6b74a --- /dev/null +++ b/service/smithyprototype/lexruntimeservice/lexruntimeserviceiface/interface.go @@ -0,0 +1,75 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +// Package lexruntimeserviceiface provides an interface to enable mocking the Amazon Lex Runtime Service service client +// for testing your code. +// +// It is important to note that this interface will have breaking changes +// when the service model is updated and adds new API operations, paginators, +// and waiters. +package lexruntimeserviceiface + +import ( + "github.com/aws/aws-sdk-go-v2/service/lexruntimeservice" +) + +// ClientAPI provides an interface to enable mocking the +// lexruntimeservice.Client methods. This make unit testing your code that +// calls out to the SDK's service client's calls easier. +// +// The best way to use this interface is so the SDK's service client's calls +// can be stubbed out for unit testing your code with the SDK without needing +// to inject custom request handlers into the SDK's request pipeline. +// +// // myFunc uses an SDK service client to make a request to +// // Amazon Lex Runtime Service. +// func myFunc(svc lexruntimeserviceiface.ClientAPI) bool { +// // Make svc.DeleteSession request +// } +// +// func main() { +// cfg, err := external.LoadDefaultAWSConfig() +// if err != nil { +// panic("failed to load config, " + err.Error()) +// } +// +// svc := lexruntimeservice.New(cfg) +// +// myFunc(svc) +// } +// +// In your _test.go file: +// +// // Define a mock struct to be used in your unit tests of myFunc. +// type mockClientClient struct { +// lexruntimeserviceiface.ClientPI +// } +// func (m *mockClientClient) DeleteSession(input *lexruntimeservice.DeleteSessionInput) (*lexruntimeservice.DeleteSessionOutput, error) { +// // mock response/functionality +// } +// +// func TestMyFunc(t *testing.T) { +// // Setup Test +// mockSvc := &mockClientClient{} +// +// myfunc(mockSvc) +// +// // Verify myFunc's functionality +// } +// +// It is important to note that this interface will have breaking changes +// when the service model is updated and adds new API operations, paginators, +// and waiters. Its suggested to use the pattern above for testing, or using +// tooling to generate mocks to satisfy the interfaces. +type ClientAPI interface { + DeleteSessionRequest(*lexruntimeservice.DeleteSessionInput) lexruntimeservice.DeleteSessionRequest + + GetSessionRequest(*lexruntimeservice.GetSessionInput) lexruntimeservice.GetSessionRequest + + PostContentRequest(*lexruntimeservice.PostContentInput) lexruntimeservice.PostContentRequest + + PostTextRequest(*lexruntimeservice.PostTextInput) lexruntimeservice.PostTextRequest + + PutSessionRequest(*lexruntimeservice.PutSessionInput) lexruntimeservice.PutSessionRequest +} + +var _ ClientAPI = (*lexruntimeservice.Client)(nil)