终止支持通知：2025年9月15日， AWS 我们将停止对Amazon Lex V1的支持。2025 年 9 月 15 日之后，您将无法再访问 Amazon Lex V1 控制台或 Amazon Lex V1 资源。如果您使用的是 Amazon Lex V2，请改为参阅 [Amazon Lex V2 指南](https://docs.aws.amazon.com/lexv2/latest/dg/what-is.html)。

本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 操作
<a name="API_Operations"></a>

Amazon Lex 模型构建服务支持以下操作：
+  [CreateBotVersion](API_CreateBotVersion.md) 
+  [CreateIntentVersion](API_CreateIntentVersion.md) 
+  [CreateSlotTypeVersion](API_CreateSlotTypeVersion.md) 
+  [DeleteBot](API_DeleteBot.md) 
+  [DeleteBotAlias](API_DeleteBotAlias.md) 
+  [DeleteBotChannelAssociation](API_DeleteBotChannelAssociation.md) 
+  [DeleteBotVersion](API_DeleteBotVersion.md) 
+  [DeleteIntent](API_DeleteIntent.md) 
+  [DeleteIntentVersion](API_DeleteIntentVersion.md) 
+  [DeleteSlotType](API_DeleteSlotType.md) 
+  [DeleteSlotTypeVersion](API_DeleteSlotTypeVersion.md) 
+  [DeleteUtterances](API_DeleteUtterances.md) 
+  [GetBot](API_GetBot.md) 
+  [GetBotAlias](API_GetBotAlias.md) 
+  [GetBotAliases](API_GetBotAliases.md) 
+  [GetBotChannelAssociation](API_GetBotChannelAssociation.md) 
+  [GetBotChannelAssociations](API_GetBotChannelAssociations.md) 
+  [GetBots](API_GetBots.md) 
+  [GetBotVersions](API_GetBotVersions.md) 
+  [GetBuiltinIntent](API_GetBuiltinIntent.md) 
+  [GetBuiltinIntents](API_GetBuiltinIntents.md) 
+  [GetBuiltinSlotTypes](API_GetBuiltinSlotTypes.md) 
+  [GetExport](API_GetExport.md) 
+  [GetImport](API_GetImport.md) 
+  [GetIntent](API_GetIntent.md) 
+  [GetIntents](API_GetIntents.md) 
+  [GetIntentVersions](API_GetIntentVersions.md) 
+  [GetMigration](API_GetMigration.md) 
+  [GetMigrations](API_GetMigrations.md) 
+  [GetSlotType](API_GetSlotType.md) 
+  [GetSlotTypes](API_GetSlotTypes.md) 
+  [GetSlotTypeVersions](API_GetSlotTypeVersions.md) 
+  [GetUtterancesView](API_GetUtterancesView.md) 
+  [ListTagsForResource](API_ListTagsForResource.md) 
+  [PutBot](API_PutBot.md) 
+  [PutBotAlias](API_PutBotAlias.md) 
+  [PutIntent](API_PutIntent.md) 
+  [PutSlotType](API_PutSlotType.md) 
+  [StartImport](API_StartImport.md) 
+  [StartMigration](API_StartMigration.md) 
+  [TagResource](API_TagResource.md) 
+  [UntagResource](API_UntagResource.md) 

Amazon Lex 运行时服务支持以下操作：
+  [DeleteSession](API_runtime_DeleteSession.md) 
+  [GetSession](API_runtime_GetSession.md) 
+  [PostContent](API_runtime_PostContent.md) 
+  [PostText](API_runtime_PostText.md) 
+  [PutSession](API_runtime_PutSession.md) 

# Amazon Lex 模型构建服务
<a name="API_Operations_Amazon_Lex_Model_Building_Service"></a>

Amazon Lex 模型构建服务支持以下操作：
+  [CreateBotVersion](API_CreateBotVersion.md) 
+  [CreateIntentVersion](API_CreateIntentVersion.md) 
+  [CreateSlotTypeVersion](API_CreateSlotTypeVersion.md) 
+  [DeleteBot](API_DeleteBot.md) 
+  [DeleteBotAlias](API_DeleteBotAlias.md) 
+  [DeleteBotChannelAssociation](API_DeleteBotChannelAssociation.md) 
+  [DeleteBotVersion](API_DeleteBotVersion.md) 
+  [DeleteIntent](API_DeleteIntent.md) 
+  [DeleteIntentVersion](API_DeleteIntentVersion.md) 
+  [DeleteSlotType](API_DeleteSlotType.md) 
+  [DeleteSlotTypeVersion](API_DeleteSlotTypeVersion.md) 
+  [DeleteUtterances](API_DeleteUtterances.md) 
+  [GetBot](API_GetBot.md) 
+  [GetBotAlias](API_GetBotAlias.md) 
+  [GetBotAliases](API_GetBotAliases.md) 
+  [GetBotChannelAssociation](API_GetBotChannelAssociation.md) 
+  [GetBotChannelAssociations](API_GetBotChannelAssociations.md) 
+  [GetBots](API_GetBots.md) 
+  [GetBotVersions](API_GetBotVersions.md) 
+  [GetBuiltinIntent](API_GetBuiltinIntent.md) 
+  [GetBuiltinIntents](API_GetBuiltinIntents.md) 
+  [GetBuiltinSlotTypes](API_GetBuiltinSlotTypes.md) 
+  [GetExport](API_GetExport.md) 
+  [GetImport](API_GetImport.md) 
+  [GetIntent](API_GetIntent.md) 
+  [GetIntents](API_GetIntents.md) 
+  [GetIntentVersions](API_GetIntentVersions.md) 
+  [GetMigration](API_GetMigration.md) 
+  [GetMigrations](API_GetMigrations.md) 
+  [GetSlotType](API_GetSlotType.md) 
+  [GetSlotTypes](API_GetSlotTypes.md) 
+  [GetSlotTypeVersions](API_GetSlotTypeVersions.md) 
+  [GetUtterancesView](API_GetUtterancesView.md) 
+  [ListTagsForResource](API_ListTagsForResource.md) 
+  [PutBot](API_PutBot.md) 
+  [PutBotAlias](API_PutBotAlias.md) 
+  [PutIntent](API_PutIntent.md) 
+  [PutSlotType](API_PutSlotType.md) 
+  [StartImport](API_StartImport.md) 
+  [StartMigration](API_StartMigration.md) 
+  [TagResource](API_TagResource.md) 
+  [UntagResource](API_UntagResource.md) 

# CreateBotVersion
<a name="API_CreateBotVersion"></a>

根据 `$LATEST` 版本创建新版本的机器人。如果自您创建上一个版本以来此资源的 `$LATEST` 版本没有更改，则 Amazon Lex 不会创建新版本。它返回上次创建的版本。

**注意**  
您只能更新 `$LATEST` 版本的机器人。您无法更新通过 `CreateBotVersion` 操作创建的带编号的版本。

 创建机器人的第一个版本时，Amazon Lex 会将版本设置为 1。后续版本递增 1。有关更多信息，请参阅 [版本控制](versioning-aliases.md#versioning-intro)。

 此操作需要 `lex:CreateBotVersion` 操作权限。

## 请求语法
<a name="API_CreateBotVersion_RequestSyntax"></a>

```
POST /bots/name/versions HTTP/1.1
Content-type: application/json

{
   "checksum": "string"
}
```

## URI 请求参数
<a name="API_CreateBotVersion_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [name](#API_CreateBotVersion_RequestSyntax) **   <a name="lex-CreateBotVersion-request-uri-name"></a>
要为其创建新版本的机器人的名称。该名称区分大小写。  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`  
必需：是

## 请求体
<a name="API_CreateBotVersion_RequestBody"></a>

请求接受采用 JSON 格式的以下数据。

 ** [checksum](#API_CreateBotVersion_RequestSyntax) **   <a name="lex-CreateBotVersion-request-checksum"></a>
标识机器人 `$LATEST` 版本的特定修订版。如果您指定了校验和，而机器人的 `$LATEST` 版本具有不同的校验和，则会返回 `PreconditionFailedException` 异常，并且 Amazon Lex 不会发布新版本。如果不指定校验和，Amazon Lex 会发布 `$LATEST` 版本。  
类型：字符串  
必需：否

## 响应语法
<a name="API_CreateBotVersion_ResponseSyntax"></a>

```
HTTP/1.1 201
Content-type: application/json

{
   "abortStatement": { 
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "checksum": "string",
   "childDirected": boolean,
   "clarificationPrompt": { 
      "maxAttempts": number,
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "createdDate": number,
   "description": "string",
   "detectSentiment": boolean,
   "enableModelImprovements": boolean,
   "failureReason": "string",
   "idleSessionTTLInSeconds": number,
   "intents": [ 
      { 
         "intentName": "string",
         "intentVersion": "string"
      }
   ],
   "lastUpdatedDate": number,
   "locale": "string",
   "name": "string",
   "status": "string",
   "version": "string",
   "voiceId": "string"
}
```

## 响应元素
<a name="API_CreateBotVersion_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 201 响应。

服务以 JSON 格式返回的以下数据。

 ** [abortStatement](#API_CreateBotVersion_ResponseSyntax) **   <a name="lex-CreateBotVersion-response-abortStatement"></a>
Amazon Lex 用来取消对话的消息。有关更多信息，请参阅 [PutBot](API_PutBot.md)。  
类型：[Statement](API_Statement.md) 对象

 ** [checksum](#API_CreateBotVersion_ResponseSyntax) **   <a name="lex-CreateBotVersion-response-checksum"></a>
校验和标识创建的机器人版本。  
类型：字符串

 ** [childDirected](#API_CreateBotVersion_ResponseSyntax) **   <a name="lex-CreateBotVersion-response-childDirected"></a>
对于使用 Amazon Lex 模型构建服务创建的每个 Amazon Lex 机器人，您都必须通过在 `childDirected` 字段中指定 `true` 或 `false`，指定您对 Amazon Lex 的使用是否与全部或部分针对 13 岁以下儿童且受《儿童在线隐私保护法》(COPPA) 约束的网站、程序或其他应用程序有关。在 `childDirected` 字段中指定 `true`，即表示您确认您对 Amazon Lex 的使用**确实**与全部或部分针对 13 岁以下儿童且受 COPPA 约束的网站、计划或其他应用程序有关。在 `childDirected` 字段中指定 `false`，即表示您确认您对 Amazon Lex 的使用**不**与全部或部分针对 13 岁以下儿童且受 COPPA 约束的网站、计划或其他应用程序有关。如果在 `childDirected` 字段中指定默认值不能正确反映您确认您对 Amazon Lex 的使用不与全部或部分针对 13 岁以下儿童且受 COPPA 约束的网站、计划或其他应用程序有关，则您可以不指定。  
如果您对 Amazon Lex 的使用涉及全部或部分针对 13 岁以下儿童的网站、程序或其他应用程序，则必须获得 COPPA 规定的任何必需的可核实的家长同意。有关将 Amazon Lex 用于全部或部分针对 13 岁以下儿童的网站、程序或其他应用程序的信息，请参阅 [Amazon Lex 常见问题解答](https://aws.amazon.com/lex/faqs#data-security)。  
类型：布尔值

 ** [clarificationPrompt](#API_CreateBotVersion_ResponseSyntax) **   <a name="lex-CreateBotVersion-response-clarificationPrompt"></a>
Amazon Lex 在无法理解用户的请求时使用的消息。有关更多信息，请参阅 [PutBot](API_PutBot.md)。  
类型：[Prompt](API_Prompt.md) 对象

 ** [createdDate](#API_CreateBotVersion_ResponseSyntax) **   <a name="lex-CreateBotVersion-response-createdDate"></a>
创建机器人版本的日期。  
类型：时间戳

 ** [description](#API_CreateBotVersion_ResponseSyntax) **   <a name="lex-CreateBotVersion-response-description"></a>
机器人的描述。  
类型：字符串  
长度限制：最小长度为 0。最大长度为 200。

 ** [detectSentiment](#API_CreateBotVersion_ResponseSyntax) **   <a name="lex-CreateBotVersion-response-detectSentiment"></a>
表示是否应将用户输入的言语发送到 Amazon Comprehend 以进行情绪分析。  
类型：布尔值

 ** [enableModelImprovements](#API_CreateBotVersion_ResponseSyntax) **   <a name="lex-CreateBotVersion-response-enableModelImprovements"></a>
表示机器人是否使用精度改进。`true` 表示机器人正在使用改进，否则为 `false`。  
类型：布尔值

 ** [failureReason](#API_CreateBotVersion_ResponseSyntax) **   <a name="lex-CreateBotVersion-response-failureReason"></a>
如果 `status` 是 `FAILED`，则 Amazon Lex 会提供其未能构建机器人的原因。  
类型：字符串

 ** [idleSessionTTLInSeconds](#API_CreateBotVersion_ResponseSyntax) **   <a name="lex-CreateBotVersion-response-idleSessionTTLInSeconds"></a>
Amazon Lex 保留对话中收集的数据的最长时间（秒）。有关更多信息，请参阅 [PutBot](API_PutBot.md)。  
类型：整数  
有效范围：最小值为 60。最大值为 86400。

 ** [intents](#API_CreateBotVersion_ResponseSyntax) **   <a name="lex-CreateBotVersion-response-intents"></a>
`Intent` 数据元数组。有关更多信息，请参阅 [PutBot](API_PutBot.md)。  
类型：[Intent](API_Intent.md) 对象数组

 ** [lastUpdatedDate](#API_CreateBotVersion_ResponseSyntax) **   <a name="lex-CreateBotVersion-response-lastUpdatedDate"></a>
此机器人 `$LATEST` 版本的更新日期。  
类型：时间戳

 ** [locale](#API_CreateBotVersion_ResponseSyntax) **   <a name="lex-CreateBotVersion-response-locale"></a>
 指定机器人的目标区域设置。  
类型：字符串  
有效值：`de-DE | en-AU | en-GB | en-IN | en-US | es-419 | es-ES | es-US | fr-FR | fr-CA | it-IT | ja-JP | ko-KR`

 ** [name](#API_CreateBotVersion_ResponseSyntax) **   <a name="lex-CreateBotVersion-response-name"></a>
机器人的名称。  
类型：字符串  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`

 ** [status](#API_CreateBotVersion_ResponseSyntax) **   <a name="lex-CreateBotVersion-response-status"></a>
 当您发送创建或更新机器人的请求时，Amazon Lex 会将 `status` 响应元素设置为 `BUILDING`。在 Amazon Lex 构建机器人之后，它会将 `status` 设置为 `READY`。如果 Amazon Lex 无法构建机器人，则它会将 `status` 设置为 `FAILED`。Amazon Lex 会在 `failureReason` 响应元素中返回失败的原因。  
类型：字符串  
有效值：`BUILDING | READY | READY_BASIC_TESTING | FAILED | NOT_BUILT`

 ** [version](#API_CreateBotVersion_ResponseSyntax) **   <a name="lex-CreateBotVersion-response-version"></a>
自动程序的版本。  
类型：字符串  
长度限制：最小长度为 1。长度上限为 64。  
模式：`\$LATEST|[0-9]+`

 ** [voiceId](#API_CreateBotVersion_ResponseSyntax) **   <a name="lex-CreateBotVersion-response-voiceId"></a>
Amazon Lex 用于和用户进行语音交互的 Amazon Polly 语音 ID。  
类型：字符串

## 错误
<a name="API_CreateBotVersion_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** ConflictException **   
 处理请求时出现冲突。请再次尝试您的请求。  
HTTP 状态代码：409

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

 ** PreconditionFailedException **   
 您尝试更改的资源的校验和与请求中的校验和不匹配。检查资源的校验和并重试。  
HTTP 状态代码：412

## 另请参阅
<a name="API_CreateBotVersion_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/CreateBotVersion) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/CreateBotVersion) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/CreateBotVersion) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/CreateBotVersion) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/CreateBotVersion) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/CreateBotVersion) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/CreateBotVersion) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/CreateBotVersion) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/CreateBotVersion) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/CreateBotVersion) 

# CreateIntentVersion
<a name="API_CreateIntentVersion"></a>

基于意图的 `$LATEST` 版本创建意图的新版本。如果自您上次更新以来此意图的 `$LATEST` 版本没有更改，则 Amazon Lex 不会创建新版本。它返回您创建的上一个版本。

**注意**  
您只能更新 `$LATEST` 版本的意图。您无法更新通过 `CreateIntentVersion` 操作创建的带编号的版本。

 创建意图的版本时，Amazon Lex 会将版本设置为 1。后续版本递增 1。有关更多信息，请参阅 [版本控制](versioning-aliases.md#versioning-intro)。

此操作需要执行 `lex:CreateIntentVersion` 操作的权限。

## 请求语法
<a name="API_CreateIntentVersion_RequestSyntax"></a>

```
POST /intents/name/versions HTTP/1.1
Content-type: application/json

{
   "checksum": "string"
}
```

## URI 请求参数
<a name="API_CreateIntentVersion_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [name](#API_CreateIntentVersion_RequestSyntax) **   <a name="lex-CreateIntentVersion-request-uri-name"></a>
要为其创建新版本的意图的名称。该名称区分大小写。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
必需：是

## 请求体
<a name="API_CreateIntentVersion_RequestBody"></a>

请求接受采用 JSON 格式的以下数据。

 ** [checksum](#API_CreateIntentVersion_RequestSyntax) **   <a name="lex-CreateIntentVersion-request-checksum"></a>
应该用于创建新版本的意图的 `$LATEST` 版本的校验和。如果您指定了校验和，而意图的 `$LATEST` 版本具有不同的校验和，则 Amazon Lex 会返回 `PreconditionFailedException` 异常，并且不会发布新版本。如果不指定校验和，Amazon Lex 会发布 `$LATEST` 版本。  
类型：字符串  
必需：否

## 响应语法
<a name="API_CreateIntentVersion_ResponseSyntax"></a>

```
HTTP/1.1 201
Content-type: application/json

{
   "checksum": "string",
   "conclusionStatement": { 
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "confirmationPrompt": { 
      "maxAttempts": number,
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "createdDate": number,
   "description": "string",
   "dialogCodeHook": { 
      "messageVersion": "string",
      "uri": "string"
   },
   "followUpPrompt": { 
      "prompt": { 
         "maxAttempts": number,
         "messages": [ 
            { 
               "content": "string",
               "contentType": "string",
               "groupNumber": number
            }
         ],
         "responseCard": "string"
      },
      "rejectionStatement": { 
         "messages": [ 
            { 
               "content": "string",
               "contentType": "string",
               "groupNumber": number
            }
         ],
         "responseCard": "string"
      }
   },
   "fulfillmentActivity": { 
      "codeHook": { 
         "messageVersion": "string",
         "uri": "string"
      },
      "type": "string"
   },
   "inputContexts": [ 
      { 
         "name": "string"
      }
   ],
   "kendraConfiguration": { 
      "kendraIndex": "string",
      "queryFilterString": "string",
      "role": "string"
   },
   "lastUpdatedDate": number,
   "name": "string",
   "outputContexts": [ 
      { 
         "name": "string",
         "timeToLiveInSeconds": number,
         "turnsToLive": number
      }
   ],
   "parentIntentSignature": "string",
   "rejectionStatement": { 
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "sampleUtterances": [ "string" ],
   "slots": [ 
      { 
         "defaultValueSpec": { 
            "defaultValueList": [ 
               { 
                  "defaultValue": "string"
               }
            ]
         },
         "description": "string",
         "name": "string",
         "obfuscationSetting": "string",
         "priority": number,
         "responseCard": "string",
         "sampleUtterances": [ "string" ],
         "slotConstraint": "string",
         "slotType": "string",
         "slotTypeVersion": "string",
         "valueElicitationPrompt": { 
            "maxAttempts": number,
            "messages": [ 
               { 
                  "content": "string",
                  "contentType": "string",
                  "groupNumber": number
               }
            ],
            "responseCard": "string"
         }
      }
   ],
   "version": "string"
}
```

## 响应元素
<a name="API_CreateIntentVersion_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 201 响应。

服务以 JSON 格式返回的以下数据。

 ** [checksum](#API_CreateIntentVersion_ResponseSyntax) **   <a name="lex-CreateIntentVersion-response-checksum"></a>
创建的意图版本的校验和。  
类型：字符串

 ** [conclusionStatement](#API_CreateIntentVersion_ResponseSyntax) **   <a name="lex-CreateIntentVersion-response-conclusionStatement"></a>
在 `fulfillmentActivity` 字段中指定的 Lambda 函数履行意图后，Amazon Lex 会将此语句传达给用户。  
类型：[Statement](API_Statement.md) 对象

 ** [confirmationPrompt](#API_CreateIntentVersion_ResponseSyntax) **   <a name="lex-CreateIntentVersion-response-confirmationPrompt"></a>
如果已定义，则是 Amazon Lex 在履行用户意图之前用于确认其意图的提示。  
类型：[Prompt](API_Prompt.md) 对象

 ** [createdDate](#API_CreateIntentVersion_ResponseSyntax) **   <a name="lex-CreateIntentVersion-response-createdDate"></a>
意图的创建日期。  
类型：时间戳

 ** [description](#API_CreateIntentVersion_ResponseSyntax) **   <a name="lex-CreateIntentVersion-response-description"></a>
目的的描述。  
类型：字符串  
长度限制：最小长度为 0。最大长度为 200。

 ** [dialogCodeHook](#API_CreateIntentVersion_ResponseSyntax) **   <a name="lex-CreateIntentVersion-response-dialogCodeHook"></a>
如果已定义，Amazon Lex 会为每个用户输入调用此 Lambda 函数。  
类型：[CodeHook](API_CodeHook.md) 对象

 ** [followUpPrompt](#API_CreateIntentVersion_ResponseSyntax) **   <a name="lex-CreateIntentVersion-response-followUpPrompt"></a>
如果已定义，Amazon Lex 将在履行意图后使用此提示来征求其他用户活动。  
类型：[FollowUpPrompt](API_FollowUpPrompt.md) 对象

 ** [fulfillmentActivity](#API_CreateIntentVersion_ResponseSyntax) **   <a name="lex-CreateIntentVersion-response-fulfillmentActivity"></a>
 描述履行意图的方式。  
类型：[FulfillmentActivity](API_FulfillmentActivity.md) 对象

 ** [inputContexts](#API_CreateIntentVersion_ResponseSyntax) **   <a name="lex-CreateIntentVersion-response-inputContexts"></a>
`InputContext` 对象数组，列出了 Amazon Lex 在与用户的对话中选择意图时必须处于活动状态的上下文。  
类型：[InputContext](API_InputContext.md) 对象数组  
数组成员：最少 0 个物品。最多 5 项。

 ** [kendraConfiguration](#API_CreateIntentVersion_ResponseSyntax) **   <a name="lex-CreateIntentVersion-response-kendraConfiguration"></a>
用于将 Amazon Kendra 索引与 `AMAZON.KendraSearchIntent` 意图关联的配置信息（如果有）。  
类型：[KendraConfiguration](API_KendraConfiguration.md) 对象

 ** [lastUpdatedDate](#API_CreateIntentVersion_ResponseSyntax) **   <a name="lex-CreateIntentVersion-response-lastUpdatedDate"></a>
意图的更新日期。  
类型：时间戳

 ** [name](#API_CreateIntentVersion_ResponseSyntax) **   <a name="lex-CreateIntentVersion-response-name"></a>
意图的名称。  
类型：字符串  
长度约束：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`

 ** [outputContexts](#API_CreateIntentVersion_ResponseSyntax) **   <a name="lex-CreateIntentVersion-response-outputContexts"></a>
`OutputContext` 对象数组，列出了履行意图时意图激活的上下文。  
类型：[OutputContext](API_OutputContext.md) 对象数组  
数组成员：最少 0 个物品。最多 10 个物品。

 ** [parentIntentSignature](#API_CreateIntentVersion_ResponseSyntax) **   <a name="lex-CreateIntentVersion-response-parentIntentSignature"></a>
内置意图唯一标识符。  
类型：字符串

 ** [rejectionStatement](#API_CreateIntentVersion_ResponseSyntax) **   <a name="lex-CreateIntentVersion-response-rejectionStatement"></a>
当用户对 `confirmationPrompt` 中定义的问题回答“否”时，Amazon Lex 将使用此语句进行响应，以确认意图已被取消。  
类型：[Statement](API_Statement.md) 对象

 ** [sampleUtterances](#API_CreateIntentVersion_ResponseSyntax) **   <a name="lex-CreateIntentVersion-response-sampleUtterances"></a>
为意图配置的示例言语数组。  
类型：字符串数组  
数组成员：最少 0 项。最多 1500 项。  
长度限制：最小长度为 1。最大长度为 200。

 ** [slots](#API_CreateIntentVersion_ResponseSyntax) **   <a name="lex-CreateIntentVersion-response-slots"></a>
插槽类型数组，用于定义履行意图所需的信息。  
类型：[Slot](API_Slot.md) 对象数组  
数组成员：最少 0 个物品。最多 100 个项目。

 ** [version](#API_CreateIntentVersion_ResponseSyntax) **   <a name="lex-CreateIntentVersion-response-version"></a>
分配给新版本意图的版本号。  
类型：字符串  
长度限制：最小长度为 1。长度上限为 64。  
模式：`\$LATEST|[0-9]+`

## 错误
<a name="API_CreateIntentVersion_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** ConflictException **   
 处理请求时出现冲突。请再次尝试您的请求。  
HTTP 状态代码：409

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

 ** PreconditionFailedException **   
 您尝试更改的资源的校验和与请求中的校验和不匹配。检查资源的校验和并重试。  
HTTP 状态代码：412

## 另请参阅
<a name="API_CreateIntentVersion_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/CreateIntentVersion) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/CreateIntentVersion) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/CreateIntentVersion) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/CreateIntentVersion) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/CreateIntentVersion) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/CreateIntentVersion) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/CreateIntentVersion) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/CreateIntentVersion) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/CreateIntentVersion) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/CreateIntentVersion) 

# CreateSlotTypeVersion
<a name="API_CreateSlotTypeVersion"></a>

基于指定插槽类型的 `$LATEST` 版本创建插槽类型的新版本。如果自您创建上一个版本以来此资源的 `$LATEST` 版本没有更改，则 Amazon Lex 不会创建新版本。它会返回您创建的上一个版本。

**注意**  
您只能更新插槽类型的 `$LATEST` 版本。您无法更新通过 `CreateSlotTypeVersion` 操作创建的带编号的版本。

创建插槽类型的版本时，Amazon Lex 会将版本设置为 1。后续版本递增 1。有关更多信息，请参阅 [版本控制](versioning-aliases.md#versioning-intro)。

此操作需要 `lex:CreateSlotTypeVersion` 操作的权限。

## 请求语法
<a name="API_CreateSlotTypeVersion_RequestSyntax"></a>

```
POST /slottypes/name/versions HTTP/1.1
Content-type: application/json

{
   "checksum": "string"
}
```

## URI 请求参数
<a name="API_CreateSlotTypeVersion_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [name](#API_CreateSlotTypeVersion_RequestSyntax) **   <a name="lex-CreateSlotTypeVersion-request-uri-name"></a>
要为其创建新版本的插槽类型的名称。该名称区分大小写。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
必需：是

## 请求体
<a name="API_CreateSlotTypeVersion_RequestBody"></a>

请求接受采用 JSON 格式的以下数据。

 ** [checksum](#API_CreateSlotTypeVersion_RequestSyntax) **   <a name="lex-CreateSlotTypeVersion-request-checksum"></a>
您要发布的插槽类型的 `$LATEST` 版本的校验和。如果您指定了校验和，并且插槽类型的 `$LATEST` 版本具有不同的校验和，则 Amazon Lex 会返回 `PreconditionFailedException` 异常且不会发布新版本。如果不指定校验和，Amazon Lex 会发布 `$LATEST` 版本。  
类型：字符串  
必需：否

## 响应语法
<a name="API_CreateSlotTypeVersion_ResponseSyntax"></a>

```
HTTP/1.1 201
Content-type: application/json

{
   "checksum": "string",
   "createdDate": number,
   "description": "string",
   "enumerationValues": [ 
      { 
         "synonyms": [ "string" ],
         "value": "string"
      }
   ],
   "lastUpdatedDate": number,
   "name": "string",
   "parentSlotTypeSignature": "string",
   "slotTypeConfigurations": [ 
      { 
         "regexConfiguration": { 
            "pattern": "string"
         }
      }
   ],
   "valueSelectionStrategy": "string",
   "version": "string"
}
```

## 响应元素
<a name="API_CreateSlotTypeVersion_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 201 响应。

服务以 JSON 格式返回的以下数据。

 ** [checksum](#API_CreateSlotTypeVersion_ResponseSyntax) **   <a name="lex-CreateSlotTypeVersion-response-checksum"></a>
插槽类型的 `$LATEST` 版本的校验和。  
类型：字符串

 ** [createdDate](#API_CreateSlotTypeVersion_ResponseSyntax) **   <a name="lex-CreateSlotTypeVersion-response-createdDate"></a>
插槽类型的创建日期。  
类型：时间戳

 ** [description](#API_CreateSlotTypeVersion_ResponseSyntax) **   <a name="lex-CreateSlotTypeVersion-response-description"></a>
槽类型的描述。  
类型：字符串  
长度限制：最小长度为 0。最大长度为 200。

 ** [enumerationValues](#API_CreateSlotTypeVersion_ResponseSyntax) **   <a name="lex-CreateSlotTypeVersion-response-enumerationValues"></a>
定义插槽类型可采用值的 `EnumerationValue` 对象的列表。  
类型：[EnumerationValue](API_EnumerationValue.md) 对象数组  
数组成员：最少 0 个物品。最多 10000 项。

 ** [lastUpdatedDate](#API_CreateSlotTypeVersion_ResponseSyntax) **   <a name="lex-CreateSlotTypeVersion-response-lastUpdatedDate"></a>
插槽类型的更新日期。创建资源时，创建日期和上次更新日期相同。  
类型：时间戳

 ** [name](#API_CreateSlotTypeVersion_ResponseSyntax) **   <a name="lex-CreateSlotTypeVersion-response-name"></a>
槽类型的名称。  
类型：字符串  
长度约束：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`

 ** [parentSlotTypeSignature](#API_CreateSlotTypeVersion_ResponseSyntax) **   <a name="lex-CreateSlotTypeVersion-response-parentSlotTypeSignature"></a>
用作此插槽类型的父级的内置插槽类型。  
类型：字符串  
长度约束：最小长度为 1。最大长度为 100。  
模式：`^((AMAZON\.)_?|[A-Za-z]_?)+`

 ** [slotTypeConfigurations](#API_CreateSlotTypeVersion_ResponseSyntax) **   <a name="lex-CreateSlotTypeVersion-response-slotTypeConfigurations"></a>
扩展父级内置插槽类型的配置信息。  
类型：[SlotTypeConfiguration](API_SlotTypeConfiguration.md) 对象数组  
数组成员：最少 0 个物品。最多 10 个物品。

 ** [valueSelectionStrategy](#API_CreateSlotTypeVersion_ResponseSyntax) **   <a name="lex-CreateSlotTypeVersion-response-valueSelectionStrategy"></a>
Amazon Lex 用来确定插槽的值的策略。有关更多信息，请参阅 [PutSlotType](API_PutSlotType.md)。  
类型：字符串  
有效值：`ORIGINAL_VALUE | TOP_RESOLUTION`

 ** [version](#API_CreateSlotTypeVersion_ResponseSyntax) **   <a name="lex-CreateSlotTypeVersion-response-version"></a>
分配给新插槽类型版本的版本。  
类型：字符串  
长度限制：最小长度为 1。长度上限为 64。  
模式：`\$LATEST|[0-9]+`

## 错误
<a name="API_CreateSlotTypeVersion_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** ConflictException **   
 处理请求时出现冲突。请再次尝试您的请求。  
HTTP 状态代码：409

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

 ** PreconditionFailedException **   
 您尝试更改的资源的校验和与请求中的校验和不匹配。检查资源的校验和并重试。  
HTTP 状态代码：412

## 另请参阅
<a name="API_CreateSlotTypeVersion_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/CreateSlotTypeVersion) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/CreateSlotTypeVersion) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/CreateSlotTypeVersion) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/CreateSlotTypeVersion) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/CreateSlotTypeVersion) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/CreateSlotTypeVersion) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/CreateSlotTypeVersion) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/CreateSlotTypeVersion) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/CreateSlotTypeVersion) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/CreateSlotTypeVersion) 

# DeleteBot
<a name="API_DeleteBot"></a>

删除机器人的所有版本，包括 `$LATEST` 版本。要删除机器人的特定版本，请使用 [DeleteBotVersion](API_DeleteBotVersion.md) 操作。`DeleteBot` 操作不会立即移除机器人架构。而是将它标记为删除并稍后删除。

Amazon Lex 无限期存储言语，以提高您的机器人响应用户输入的能力。删除机器人后，这些言语不会被删除。要删除言语，请使用 [DeleteUtterances](API_DeleteUtterances.md) 操作。

如果机器人有别名，您将无法删除它。相反，`DeleteBot` 操作会返回一个 `ResourceInUseException` 异常，其中包含对引用机器人的别名的引用。要删除对机器人的引用，请删除别名。如果您再次遇到同样的异常，请删除引用别名，直到 `DeleteBot` 操作成功。

此操作需要 `lex:DeleteBot` 操作的权限。

## 请求语法
<a name="API_DeleteBot_RequestSyntax"></a>

```
DELETE /bots/name HTTP/1.1
```

## URI 请求参数
<a name="API_DeleteBot_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [name](#API_DeleteBot_RequestSyntax) **   <a name="lex-DeleteBot-request-uri-name"></a>
机器人的名称。该名称区分大小写。  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`  
必需：是

## 请求体
<a name="API_DeleteBot_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_DeleteBot_ResponseSyntax"></a>

```
HTTP/1.1 204
```

## 响应元素
<a name="API_DeleteBot_ResponseElements"></a>

如果此操作成功，则该服务会发送回带有空 HTTP 正文的 HTTP 204 响应。

## 错误
<a name="API_DeleteBot_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** ConflictException **   
 处理请求时出现冲突。请再次尝试您的请求。  
HTTP 状态代码：409

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

 ** ResourceInUseException **   
您尝试删除的资源被其他资源引用。使用此信息来删除对您正在尝试删除的资源的引用。  
异常的正文包含描述资源的 JSON 对象。  
 `{ "resourceType": BOT | BOTALIAS | BOTCHANNEL | INTENT,`   
 `"resourceReference": {`   
 `"name": string, "version": string } }`     
 ** exampleReference **   
描述的资源引用您正在尝试删除的资源。此对象作为 `ResourceInUseException` 异常的一部分返回。
HTTP 状态代码：400

## 另请参阅
<a name="API_DeleteBot_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/DeleteBot) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/DeleteBot) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/DeleteBot) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/DeleteBot) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/DeleteBot) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/DeleteBot) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/DeleteBot) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/DeleteBot) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/DeleteBot) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/DeleteBot) 

# DeleteBotAlias
<a name="API_DeleteBotAlias"></a>

删除指定自动程序的别名。

您无法删除在机器人与消息收发通道之间的关联中使用的别名。如果在通道关联中使用别名，则 `DeleteBot` 操作会返回一个 `ResourceInUseException` 异常，其中包含对引用该机器人的通道关联的引用。您可以通过删除通道关联来删除对别名的引用。如果您再次遇到同样的异常，请删除引用关联，直到 `DeleteBotAlias` 操作成功。

## 请求语法
<a name="API_DeleteBotAlias_RequestSyntax"></a>

```
DELETE /bots/botName/aliases/name HTTP/1.1
```

## URI 请求参数
<a name="API_DeleteBotAlias_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [botName](#API_DeleteBotAlias_RequestSyntax) **   <a name="lex-DeleteBotAlias-request-uri-botName"></a>
别名指向的自动程序的名称。  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [name](#API_DeleteBotAlias_RequestSyntax) **   <a name="lex-DeleteBotAlias-request-uri-name"></a>
要删除的别名的名称。该名称区分大小写。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
必需：是

## 请求体
<a name="API_DeleteBotAlias_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_DeleteBotAlias_ResponseSyntax"></a>

```
HTTP/1.1 204
```

## 响应元素
<a name="API_DeleteBotAlias_ResponseElements"></a>

如果此操作成功，则该服务会发送回带有空 HTTP 正文的 HTTP 204 响应。

## 错误
<a name="API_DeleteBotAlias_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** ConflictException **   
 处理请求时出现冲突。请再次尝试您的请求。  
HTTP 状态代码：409

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

 ** ResourceInUseException **   
您尝试删除的资源被其他资源引用。使用此信息来删除对您正在尝试删除的资源的引用。  
异常的正文包含描述资源的 JSON 对象。  
 `{ "resourceType": BOT | BOTALIAS | BOTCHANNEL | INTENT,`   
 `"resourceReference": {`   
 `"name": string, "version": string } }`     
 ** exampleReference **   
描述的资源引用您正在尝试删除的资源。此对象作为 `ResourceInUseException` 异常的一部分返回。
HTTP 状态代码：400

## 另请参阅
<a name="API_DeleteBotAlias_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/DeleteBotAlias) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/DeleteBotAlias) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/DeleteBotAlias) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/DeleteBotAlias) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/DeleteBotAlias) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/DeleteBotAlias) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/DeleteBotAlias) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/DeleteBotAlias) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/DeleteBotAlias) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/DeleteBotAlias) 

# DeleteBotChannelAssociation
<a name="API_DeleteBotChannelAssociation"></a>

删除 Amazon Lex 机器人和消息收发平台之间的关联。

此操作需要 `lex:DeleteBotChannelAssociation` 操作权限。

## 请求语法
<a name="API_DeleteBotChannelAssociation_RequestSyntax"></a>

```
DELETE /bots/botName/aliases/aliasName/channels/name HTTP/1.1
```

## URI 请求参数
<a name="API_DeleteBotChannelAssociation_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [aliasName](#API_DeleteBotChannelAssociation_RequestSyntax) **   <a name="lex-DeleteBotChannelAssociation-request-uri-botAlias"></a>
指向与之建立此关联的 Amazon Lex 机器人的特定版本的别名。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [botName](#API_DeleteBotChannelAssociation_RequestSyntax) **   <a name="lex-DeleteBotChannelAssociation-request-uri-botName"></a>
Amazon Lex 机器人的名称。  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [name](#API_DeleteBotChannelAssociation_RequestSyntax) **   <a name="lex-DeleteBotChannelAssociation-request-uri-name"></a>
关联的名称。该名称区分大小写。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
必需：是

## 请求体
<a name="API_DeleteBotChannelAssociation_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_DeleteBotChannelAssociation_ResponseSyntax"></a>

```
HTTP/1.1 204
```

## 响应元素
<a name="API_DeleteBotChannelAssociation_ResponseElements"></a>

如果此操作成功，则该服务会发送回带有空 HTTP 正文的 HTTP 204 响应。

## 错误
<a name="API_DeleteBotChannelAssociation_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** ConflictException **   
 处理请求时出现冲突。请再次尝试您的请求。  
HTTP 状态代码：409

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_DeleteBotChannelAssociation_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/DeleteBotChannelAssociation) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/DeleteBotChannelAssociation) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/DeleteBotChannelAssociation) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/DeleteBotChannelAssociation) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/DeleteBotChannelAssociation) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/DeleteBotChannelAssociation) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/DeleteBotChannelAssociation) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/DeleteBotChannelAssociation) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/DeleteBotChannelAssociation) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/DeleteBotChannelAssociation) 

# DeleteBotVersion
<a name="API_DeleteBotVersion"></a>

删除机器人的特定版本。要删除机器人的所有版本，请使用 [DeleteBot](API_DeleteBot.md) 操作。

此操作需要 `lex:DeleteBotVersion` 操作的权限。

## 请求语法
<a name="API_DeleteBotVersion_RequestSyntax"></a>

```
DELETE /bots/name/versions/version HTTP/1.1
```

## URI 请求参数
<a name="API_DeleteBotVersion_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [name](#API_DeleteBotVersion_RequestSyntax) **   <a name="lex-DeleteBotVersion-request-uri-name"></a>
机器人的名称。  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [version](#API_DeleteBotVersion_RequestSyntax) **   <a name="lex-DeleteBotVersion-request-uri-version"></a>
待删除机器人的版本。机器人的 `$LATEST` 版本无法删除。要删除 `$LATEST` 版本，请使用 [DeleteBot](API_DeleteBot.md) 操作。  
长度限制：最小长度为 1。长度上限为 64。  
模式：`[0-9]+`  
必需：是

## 请求体
<a name="API_DeleteBotVersion_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_DeleteBotVersion_ResponseSyntax"></a>

```
HTTP/1.1 204
```

## 响应元素
<a name="API_DeleteBotVersion_ResponseElements"></a>

如果此操作成功，则该服务会发送回带有空 HTTP 正文的 HTTP 204 响应。

## 错误
<a name="API_DeleteBotVersion_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** ConflictException **   
 处理请求时出现冲突。请再次尝试您的请求。  
HTTP 状态代码：409

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

 ** ResourceInUseException **   
您尝试删除的资源被其他资源引用。使用此信息来删除对您正在尝试删除的资源的引用。  
异常的正文包含描述资源的 JSON 对象。  
 `{ "resourceType": BOT | BOTALIAS | BOTCHANNEL | INTENT,`   
 `"resourceReference": {`   
 `"name": string, "version": string } }`     
 ** exampleReference **   
描述的资源引用您正在尝试删除的资源。此对象作为 `ResourceInUseException` 异常的一部分返回。
HTTP 状态代码：400

## 另请参阅
<a name="API_DeleteBotVersion_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/DeleteBotVersion) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/DeleteBotVersion) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/DeleteBotVersion) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/DeleteBotVersion) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/DeleteBotVersion) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/DeleteBotVersion) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/DeleteBotVersion) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/DeleteBotVersion) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/DeleteBotVersion) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/DeleteBotVersion) 

# DeleteIntent
<a name="API_DeleteIntent"></a>

删除意图的所有版本，包括 `$LATEST` 版本。要删除意图的特定版本，请使用 [DeleteIntentVersion](API_DeleteIntentVersion.md) 操作。

 只有意图版本未被引用时，您才能删除该意图版本。要删除一个或多个机器人中引用的意图（请参阅[Amazon Lex：工作原理](how-it-works.md)），必须先删除这些引用。

**注意**  
 如果您遇到 `ResourceInUseException` 异常，它会提供一个示例参考，显示意图的引用位置。要删除对意图的引用，请更新机器人或将其删除。如果您再次尝试删除意图时遇到同样的异常，请重复此操作，直到意图没有引用并且调用 `DeleteIntent` 成功。

 此操作需要 `lex:DeleteIntent` 操作权限。

## 请求语法
<a name="API_DeleteIntent_RequestSyntax"></a>

```
DELETE /intents/name HTTP/1.1
```

## URI 请求参数
<a name="API_DeleteIntent_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [name](#API_DeleteIntent_RequestSyntax) **   <a name="lex-DeleteIntent-request-uri-name"></a>
意图的名称。该名称区分大小写。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
必需：是

## 请求体
<a name="API_DeleteIntent_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_DeleteIntent_ResponseSyntax"></a>

```
HTTP/1.1 204
```

## 响应元素
<a name="API_DeleteIntent_ResponseElements"></a>

如果此操作成功，则该服务会发送回带有空 HTTP 正文的 HTTP 204 响应。

## 错误
<a name="API_DeleteIntent_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** ConflictException **   
 处理请求时出现冲突。请再次尝试您的请求。  
HTTP 状态代码：409

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

 ** ResourceInUseException **   
您尝试删除的资源被其他资源引用。使用此信息来删除对您正在尝试删除的资源的引用。  
异常的正文包含描述资源的 JSON 对象。  
 `{ "resourceType": BOT | BOTALIAS | BOTCHANNEL | INTENT,`   
 `"resourceReference": {`   
 `"name": string, "version": string } }`     
 ** exampleReference **   
描述的资源引用您正在尝试删除的资源。此对象作为 `ResourceInUseException` 异常的一部分返回。
HTTP 状态代码：400

## 另请参阅
<a name="API_DeleteIntent_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/DeleteIntent) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/DeleteIntent) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/DeleteIntent) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/DeleteIntent) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/DeleteIntent) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/DeleteIntent) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/DeleteIntent) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/DeleteIntent) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/DeleteIntent) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/DeleteIntent) 

# DeleteIntentVersion
<a name="API_DeleteIntentVersion"></a>

删除目的的特定版本。要删除意图的所有版本，请使用 [DeleteIntent](API_DeleteIntent.md) 操作。

此操作需要 `lex:DeleteIntentVersion` 操作的权限。

## 请求语法
<a name="API_DeleteIntentVersion_RequestSyntax"></a>

```
DELETE /intents/name/versions/version HTTP/1.1
```

## URI 请求参数
<a name="API_DeleteIntentVersion_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [name](#API_DeleteIntentVersion_RequestSyntax) **   <a name="lex-DeleteIntentVersion-request-uri-name"></a>
意图的名称。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [version](#API_DeleteIntentVersion_RequestSyntax) **   <a name="lex-DeleteIntentVersion-request-uri-version"></a>
要删除的意图的版本。意图的 `$LATEST` 版本无法删除。要删除 `$LATEST` 版本，请使用 [DeleteIntent](API_DeleteIntent.md) 操作。  
长度限制：最小长度为 1。长度上限为 64。  
模式：`[0-9]+`  
必需：是

## 请求体
<a name="API_DeleteIntentVersion_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_DeleteIntentVersion_ResponseSyntax"></a>

```
HTTP/1.1 204
```

## 响应元素
<a name="API_DeleteIntentVersion_ResponseElements"></a>

如果此操作成功，则该服务会发送回带有空 HTTP 正文的 HTTP 204 响应。

## 错误
<a name="API_DeleteIntentVersion_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** ConflictException **   
 处理请求时出现冲突。请再次尝试您的请求。  
HTTP 状态代码：409

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

 ** ResourceInUseException **   
您尝试删除的资源被其他资源引用。使用此信息来删除对您正在尝试删除的资源的引用。  
异常的正文包含描述资源的 JSON 对象。  
 `{ "resourceType": BOT | BOTALIAS | BOTCHANNEL | INTENT,`   
 `"resourceReference": {`   
 `"name": string, "version": string } }`     
 ** exampleReference **   
描述的资源引用您正在尝试删除的资源。此对象作为 `ResourceInUseException` 异常的一部分返回。
HTTP 状态代码：400

## 另请参阅
<a name="API_DeleteIntentVersion_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/DeleteIntentVersion) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/DeleteIntentVersion) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/DeleteIntentVersion) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/DeleteIntentVersion) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/DeleteIntentVersion) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/DeleteIntentVersion) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/DeleteIntentVersion) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/DeleteIntentVersion) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/DeleteIntentVersion) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/DeleteIntentVersion) 

# DeleteSlotType
<a name="API_DeleteSlotType"></a>

删除插槽类型的所有版本，包括 `$LATEST` 版本。要删除插槽类型的特定版本，请使用 [DeleteSlotTypeVersion](API_DeleteSlotTypeVersion.md) 操作。

 只有插槽类型版本未被引用时，您才能删除该插槽类型版本。要删除一个或多个意图中引用的插槽类型，必须先删除这些引用。

**注意**  
 如果您遇到 `ResourceInUseException` 异常，则该异常会提供一个示例参考，其中显示了引用插槽类型的意图。要删除对插槽类型的引用，请更新意图或将其删除。如果您再次尝试删除插槽类型时遇到同样的异常，请重复此操作，直到该插槽类型没有引用并且调用 `DeleteSlotType` 成功。

此操作需要 `lex:DeleteSlotType` 操作权限。

## 请求语法
<a name="API_DeleteSlotType_RequestSyntax"></a>

```
DELETE /slottypes/name HTTP/1.1
```

## URI 请求参数
<a name="API_DeleteSlotType_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [name](#API_DeleteSlotType_RequestSyntax) **   <a name="lex-DeleteSlotType-request-uri-name"></a>
槽类型的名称。该名称区分大小写。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
必需：是

## 请求体
<a name="API_DeleteSlotType_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_DeleteSlotType_ResponseSyntax"></a>

```
HTTP/1.1 204
```

## 响应元素
<a name="API_DeleteSlotType_ResponseElements"></a>

如果此操作成功，则该服务会发送回带有空 HTTP 正文的 HTTP 204 响应。

## 错误
<a name="API_DeleteSlotType_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** ConflictException **   
 处理请求时出现冲突。请再次尝试您的请求。  
HTTP 状态代码：409

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

 ** ResourceInUseException **   
您尝试删除的资源被其他资源引用。使用此信息来删除对您正在尝试删除的资源的引用。  
异常的正文包含描述资源的 JSON 对象。  
 `{ "resourceType": BOT | BOTALIAS | BOTCHANNEL | INTENT,`   
 `"resourceReference": {`   
 `"name": string, "version": string } }`     
 ** exampleReference **   
描述的资源引用您正在尝试删除的资源。此对象作为 `ResourceInUseException` 异常的一部分返回。
HTTP 状态代码：400

## 另请参阅
<a name="API_DeleteSlotType_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/DeleteSlotType) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/DeleteSlotType) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/DeleteSlotType) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/DeleteSlotType) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/DeleteSlotType) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/DeleteSlotType) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/DeleteSlotType) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/DeleteSlotType) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/DeleteSlotType) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/DeleteSlotType) 

# DeleteSlotTypeVersion
<a name="API_DeleteSlotTypeVersion"></a>

删除槽类型的特定版本。要删除插槽类型的所有版本，请使用 [DeleteSlotType](API_DeleteSlotType.md) 操作。

此操作需要 `lex:DeleteSlotTypeVersion` 操作的权限。

## 请求语法
<a name="API_DeleteSlotTypeVersion_RequestSyntax"></a>

```
DELETE /slottypes/name/version/version HTTP/1.1
```

## URI 请求参数
<a name="API_DeleteSlotTypeVersion_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [name](#API_DeleteSlotTypeVersion_RequestSyntax) **   <a name="lex-DeleteSlotTypeVersion-request-uri-name"></a>
槽类型的名称。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [version](#API_DeleteSlotTypeVersion_RequestSyntax) **   <a name="lex-DeleteSlotTypeVersion-request-uri-version"></a>
要删除的插槽类型的版本。插槽类型的 `$LATEST` 版本无法删除。要删除 `$LATEST` 版本，请使用 [DeleteSlotType](API_DeleteSlotType.md) 操作。  
长度限制：最小长度为 1。长度上限为 64。  
模式：`[0-9]+`  
必需：是

## 请求体
<a name="API_DeleteSlotTypeVersion_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_DeleteSlotTypeVersion_ResponseSyntax"></a>

```
HTTP/1.1 204
```

## 响应元素
<a name="API_DeleteSlotTypeVersion_ResponseElements"></a>

如果此操作成功，则该服务会发送回带有空 HTTP 正文的 HTTP 204 响应。

## 错误
<a name="API_DeleteSlotTypeVersion_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** ConflictException **   
 处理请求时出现冲突。请再次尝试您的请求。  
HTTP 状态代码：409

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

 ** ResourceInUseException **   
您尝试删除的资源被其他资源引用。使用此信息来删除对您正在尝试删除的资源的引用。  
异常的正文包含描述资源的 JSON 对象。  
 `{ "resourceType": BOT | BOTALIAS | BOTCHANNEL | INTENT,`   
 `"resourceReference": {`   
 `"name": string, "version": string } }`     
 ** exampleReference **   
描述的资源引用您正在尝试删除的资源。此对象作为 `ResourceInUseException` 异常的一部分返回。
HTTP 状态代码：400

## 另请参阅
<a name="API_DeleteSlotTypeVersion_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/DeleteSlotTypeVersion) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/DeleteSlotTypeVersion) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/DeleteSlotTypeVersion) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/DeleteSlotTypeVersion) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/DeleteSlotTypeVersion) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/DeleteSlotTypeVersion) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/DeleteSlotTypeVersion) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/DeleteSlotTypeVersion) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/DeleteSlotTypeVersion) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/DeleteSlotTypeVersion) 

# DeleteUtterances
<a name="API_DeleteUtterances"></a>

删除存储的言语。

Amazon Lex 存储用户发送给您的机器人的言语。言语会存储 15 天以供 [GetUtterancesView](API_GetUtterancesView.md) 操作使用，然后无限期存储，用于提高机器人响应用户输入的能力。

使用 `DeleteUtterances` 操作来为特定用户手动删除存储的言语。当您使用 `DeleteUtterances` 操作时，为提高机器人响应用户输入的能力而存储的言语会立即被删除。存储用于 `GetUtterancesView` 操作的言语将在 15 天后删除。

此操作需要 `lex:DeleteUtterances` 操作的权限。

## 请求语法
<a name="API_DeleteUtterances_RequestSyntax"></a>

```
DELETE /bots/botName/utterances/userId HTTP/1.1
```

## URI 请求参数
<a name="API_DeleteUtterances_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [botName](#API_DeleteUtterances_RequestSyntax) **   <a name="lex-DeleteUtterances-request-uri-botName"></a>
存储言语的机器人的名称。  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [userId](#API_DeleteUtterances_RequestSyntax) **   <a name="lex-DeleteUtterances-request-uri-userId"></a>
 发表言语的用户的唯一标识符。这是在包含话语的[PostContent](https://docs.aws.amazon.com/lex/latest/dg/API_runtime_PostContent.html)或[PostText](https://docs.aws.amazon.com/lex/latest/dg/API_runtime_PostText.html)操作请求中发送的用户 ID。  
长度限制：最小长度为 2。最大长度为 100。  
是否必需：是

## 请求体
<a name="API_DeleteUtterances_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_DeleteUtterances_ResponseSyntax"></a>

```
HTTP/1.1 204
```

## 响应元素
<a name="API_DeleteUtterances_ResponseElements"></a>

如果此操作成功，则该服务会发送回带有空 HTTP 正文的 HTTP 204 响应。

## 错误
<a name="API_DeleteUtterances_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_DeleteUtterances_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/DeleteUtterances) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/DeleteUtterances) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/DeleteUtterances) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/DeleteUtterances) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/DeleteUtterances) 
+  [AWS JavaScript V3 版软件开发工具包](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/DeleteUtterances) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/DeleteUtterances) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/DeleteUtterances) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/DeleteUtterances) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/DeleteUtterances) 

# GetBot
<a name="API_GetBot"></a>

返回特定机器人的元数据信息。您必须提供机器人名称和机器人版本或别名。

 此操作需要 `lex:GetBot` 操作的权限。

## 请求语法
<a name="API_GetBot_RequestSyntax"></a>

```
GET /bots/name/versions/versionoralias HTTP/1.1
```

## URI 请求参数
<a name="API_GetBot_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [name](#API_GetBot_RequestSyntax) **   <a name="lex-GetBot-request-uri-name"></a>
机器人的名称。该名称区分大小写。  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [versionoralias](#API_GetBot_RequestSyntax) **   <a name="lex-GetBot-request-uri-versionOrAlias"></a>
机器人的版本或别名。  
是否必需：是

## 请求体
<a name="API_GetBot_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetBot_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "abortStatement": { 
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "checksum": "string",
   "childDirected": boolean,
   "clarificationPrompt": { 
      "maxAttempts": number,
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "createdDate": number,
   "description": "string",
   "detectSentiment": boolean,
   "enableModelImprovements": boolean,
   "failureReason": "string",
   "idleSessionTTLInSeconds": number,
   "intents": [ 
      { 
         "intentName": "string",
         "intentVersion": "string"
      }
   ],
   "lastUpdatedDate": number,
   "locale": "string",
   "name": "string",
   "nluIntentConfidenceThreshold": number,
   "status": "string",
   "version": "string",
   "voiceId": "string"
}
```

## 响应元素
<a name="API_GetBot_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [abortStatement](#API_GetBot_ResponseSyntax) **   <a name="lex-GetBot-response-abortStatement"></a>
当用户选择在不完成对话的情况下结束对话时，Amazon Lex 返回的消息。有关更多信息，请参阅 [PutBot](API_PutBot.md)。  
类型：[Statement](API_Statement.md) 对象

 ** [checksum](#API_GetBot_ResponseSyntax) **   <a name="lex-GetBot-response-checksum"></a>
用于识别机器人 `$LATEST` 版本的特定修订版的机器人的校验和。  
类型：字符串

 ** [childDirected](#API_GetBot_ResponseSyntax) **   <a name="lex-GetBot-response-childDirected"></a>
对于使用 Amazon Lex 模型构建服务创建的每个 Amazon Lex 机器人，您都必须通过在 `childDirected` 字段中指定 `true` 或 `false`，指定您对 Amazon Lex 的使用是否与全部或部分针对 13 岁以下儿童且受《儿童在线隐私保护法》(COPPA) 约束的网站、程序或其他应用程序有关。在 `childDirected` 字段中指定 `true`，即表示您确认您对 Amazon Lex 的使用**确实**与全部或部分针对 13 岁以下儿童且受 COPPA 约束的网站、计划或其他应用程序有关。在 `childDirected` 字段中指定 `false`，即表示您确认您对 Amazon Lex 的使用**不**与全部或部分针对 13 岁以下儿童且受 COPPA 约束的网站、计划或其他应用程序有关。如果在 `childDirected` 字段中指定默认值不能正确反映您确认您对 Amazon Lex 的使用不与全部或部分针对 13 岁以下儿童且受 COPPA 约束的网站、计划或其他应用程序有关，则您可以不指定。  
如果您对 Amazon Lex 的使用涉及全部或部分针对 13 岁以下儿童的网站、程序或其他应用程序，则必须获得 COPPA 规定的任何必需的可核实的家长同意。有关将 Amazon Lex 用于全部或部分针对 13 岁以下儿童的网站、程序或其他应用程序的信息，请参阅 [Amazon Lex 常见问题解答](https://aws.amazon.com/lex/faqs#data-security)。  
类型：布尔值

 ** [clarificationPrompt](#API_GetBot_ResponseSyntax) **   <a name="lex-GetBot-response-clarificationPrompt"></a>
Amazon Lex 在无法理解用户的请求时使用的消息。有关更多信息，请参阅 [PutBot](API_PutBot.md)。  
类型：[Prompt](API_Prompt.md) 对象

 ** [createdDate](#API_GetBot_ResponseSyntax) **   <a name="lex-GetBot-response-createdDate"></a>
机器人的创建日期。  
类型：时间戳

 ** [description](#API_GetBot_ResponseSyntax) **   <a name="lex-GetBot-response-description"></a>
机器人的描述。  
类型：字符串  
长度限制：最小长度为 0。最大长度为 200。

 ** [detectSentiment](#API_GetBot_ResponseSyntax) **   <a name="lex-GetBot-response-detectSentiment"></a>
表示是否应将用户言语发送到 Amazon Comprehend 以进行情绪分析。  
类型：布尔值

 ** [enableModelImprovements](#API_GetBot_ResponseSyntax) **   <a name="lex-GetBot-response-enableModelImprovements"></a>
表示机器人是否使用精度改进。`true` 表示机器人正在使用改进，否则为 `false`。  
类型：布尔值

 ** [failureReason](#API_GetBot_ResponseSyntax) **   <a name="lex-GetBot-response-failureReason"></a>
如果 `status` 是 `FAILED`，Amazon Lex 会解释为什么它未能构建该机器人。  
类型：字符串

 ** [idleSessionTTLInSeconds](#API_GetBot_ResponseSyntax) **   <a name="lex-GetBot-response-idleSessionTTLInSeconds"></a>
Amazon Lex 保留对话中收集的数据的最长时间（秒）。有关更多信息，请参阅 [PutBot](API_PutBot.md)。  
类型：整数  
有效范围：最小值为 60。最大值为 86400。

 ** [intents](#API_GetBot_ResponseSyntax) **   <a name="lex-GetBot-response-intents"></a>
`intent` 数据元数组。有关更多信息，请参阅 [PutBot](API_PutBot.md)。  
类型：[Intent](API_Intent.md) 对象数组

 ** [lastUpdatedDate](#API_GetBot_ResponseSyntax) **   <a name="lex-GetBot-response-lastUpdatedDate"></a>
机器人的更新日期。创建资源时，创建日期和上次更新日期相同。  
类型：时间戳

 ** [locale](#API_GetBot_ResponseSyntax) **   <a name="lex-GetBot-response-locale"></a>
 机器人的目标区域设置。  
类型：字符串  
有效值：`de-DE | en-AU | en-GB | en-IN | en-US | es-419 | es-ES | es-US | fr-FR | fr-CA | it-IT | ja-JP | ko-KR`

 ** [name](#API_GetBot_ResponseSyntax) **   <a name="lex-GetBot-response-name"></a>
机器人的名称。  
类型：字符串  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`

 ** [nluIntentConfidenceThreshold](#API_GetBot_ResponseSyntax) **   <a name="lex-GetBot-response-nluIntentConfidenceThreshold"></a>
该分数决定 Amazon Lex 在或[PostText](https://docs.aws.amazon.com/lex/latest/dg/API_runtime_PostText.html)响应中返回替代意图时在何处插入`AMAZON.KendraSearchIntent`、[PostContent](https://docs.aws.amazon.com/lex/latest/dg/API_runtime_PostContent.html)或两者。`AMAZON.FallbackIntent` `AMAZON.FallbackIntent`如果实际可信度分数低于此值，则会插入。 `AMAZON.KendraSearchIntent`只有在为机器人配置时才会插入。  
类型：双精度  
有效范围：最小值为 0。最大值为 1。

 ** [status](#API_GetBot_ResponseSyntax) **   <a name="lex-GetBot-response-status"></a>
机器人的状态。  
当状态为 `BUILDING` 时，Amazon Lex 正在构建机器人以供测试和使用。  
如果机器人的状态为 `READY_BASIC_TESTING`，则可以使用机器人意图中指定的确切言语来测试机器人。当机器人准备好进行全面测试或运行时，状态为 `READY`。  
如果在构建机器人时出现问题，则状态为 `FAILED`，并且 `failureReason` 字段解释了为什么没有构建机器人。  
如果机器人已保存但未构建，则状态为 `NOT_BUILT`。  
类型：字符串  
有效值：`BUILDING | READY | READY_BASIC_TESTING | FAILED | NOT_BUILT`

 ** [version](#API_GetBot_ResponseSyntax) **   <a name="lex-GetBot-response-version"></a>
自动程序的版本。对于新机器人，版本始终是 `$LATEST`。  
类型：字符串  
长度限制：最小长度为 1。长度上限为 64。  
模式：`\$LATEST|[0-9]+`

 ** [voiceId](#API_GetBot_ResponseSyntax) **   <a name="lex-GetBot-response-voiceId"></a>
Amazon Lex 用于和用户进行语音交互的 Amazon Polly 语音 ID。有关更多信息，请参阅 [PutBot](API_PutBot.md)。  
类型：字符串

## 错误
<a name="API_GetBot_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_GetBot_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBot) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetBot) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetBot) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBot) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetBot) 
+  [AWS JavaScript V3 版软件开发工具包](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetBot) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetBot) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBot) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetBot) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetBot) 

# GetBotAlias
<a name="API_GetBotAlias"></a>

返回有关 Amazon Lex 机器人别名的信息。有关别名的更多信息，请参阅[版本控制和别名](versioning-aliases.md)。

此操作需要 `lex:GetBotAlias` 操作的权限。

## 请求语法
<a name="API_GetBotAlias_RequestSyntax"></a>

```
GET /bots/botName/aliases/name HTTP/1.1
```

## URI 请求参数
<a name="API_GetBotAlias_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [botName](#API_GetBotAlias_RequestSyntax) **   <a name="lex-GetBotAlias-request-uri-botName"></a>
机器人的名称。  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [name](#API_GetBotAlias_RequestSyntax) **   <a name="lex-GetBotAlias-request-uri-name"></a>
自动程序别名的名称。该名称区分大小写。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
必需：是

## 请求体
<a name="API_GetBotAlias_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetBotAlias_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "botName": "string",
   "botVersion": "string",
   "checksum": "string",
   "conversationLogs": { 
      "iamRoleArn": "string",
      "logSettings": [ 
         { 
            "destination": "string",
            "kmsKeyArn": "string",
            "logType": "string",
            "resourceArn": "string",
            "resourcePrefix": "string"
         }
      ]
   },
   "createdDate": number,
   "description": "string",
   "lastUpdatedDate": number,
   "name": "string"
}
```

## 响应元素
<a name="API_GetBotAlias_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [botName](#API_GetBotAlias_ResponseSyntax) **   <a name="lex-GetBotAlias-response-botName"></a>
别名指向的自动程序的名称。  
类型：字符串  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`

 ** [botVersion](#API_GetBotAlias_ResponseSyntax) **   <a name="lex-GetBotAlias-response-botVersion"></a>
别名指向的机器人的版本。  
类型：字符串  
长度限制：最小长度为 1。长度上限为 64。  
模式：`\$LATEST|[0-9]+`

 ** [checksum](#API_GetBotAlias_ResponseSyntax) **   <a name="lex-GetBotAlias-response-checksum"></a>
机器人别名的校验和。  
类型：字符串

 ** [conversationLogs](#API_GetBotAlias_ResponseSyntax) **   <a name="lex-GetBotAlias-response-conversationLogs"></a>
确定 Amazon Lex 如何使用对话日志作为别名的设置。  
类型：[ConversationLogsResponse](API_ConversationLogsResponse.md) 对象

 ** [createdDate](#API_GetBotAlias_ResponseSyntax) **   <a name="lex-GetBotAlias-response-createdDate"></a>
机器人别名的创建日期。  
类型：时间戳

 ** [description](#API_GetBotAlias_ResponseSyntax) **   <a name="lex-GetBotAlias-response-description"></a>
机器人别名的描述。  
类型：字符串  
长度限制：最小长度为 0。最大长度为 200。

 ** [lastUpdatedDate](#API_GetBotAlias_ResponseSyntax) **   <a name="lex-GetBotAlias-response-lastUpdatedDate"></a>
机器人别名的更新日期。创建资源时，创建日期和上次更新日期相同。  
类型：时间戳

 ** [name](#API_GetBotAlias_ResponseSyntax) **   <a name="lex-GetBotAlias-response-name"></a>
自动程序别名的名称。  
类型：字符串  
长度约束：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`

## 错误
<a name="API_GetBotAlias_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_GetBotAlias_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBotAlias) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetBotAlias) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetBotAlias) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBotAlias) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetBotAlias) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetBotAlias) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetBotAlias) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBotAlias) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetBotAlias) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetBotAlias) 

# GetBotAliases
<a name="API_GetBotAliases"></a>

返回指定 Amazon Lex 机器人的别名列表。

此操作需要 `lex:GetBotAliases` 操作的权限。

## 请求语法
<a name="API_GetBotAliases_RequestSyntax"></a>

```
GET /bots/botName/aliases/?maxResults=maxResults&nameContains=nameContains&nextToken=nextToken HTTP/1.1
```

## URI 请求参数
<a name="API_GetBotAliases_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [botName](#API_GetBotAliases_RequestSyntax) **   <a name="lex-GetBotAliases-request-uri-botName"></a>
机器人的名称。  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [maxResults](#API_GetBotAliases_RequestSyntax) **   <a name="lex-GetBotAliases-request-uri-maxResults"></a>
要在响应中返回的别名的最大数量。默认值为 50。  
有效范围：最小值为 1。最大值为 50。

 ** [nameContains](#API_GetBotAliases_RequestSyntax) **   <a name="lex-GetBotAliases-request-uri-nameContains"></a>
机器人别名中要匹配的子字符串。如果别名名称的任何部分与子字符串匹配，则将返回别名。例如，“xyz”同时匹配“xyzabc”和“abcxyz”。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`

 ** [nextToken](#API_GetBotAliases_RequestSyntax) **   <a name="lex-GetBotAliases-request-uri-nextToken"></a>
用于获取下一页别名的分页令牌。如果对此调用的响应被截断，Amazon Lex 将在响应中返回分页令牌。要获取下一页的别名，请在下一个请求中指定分页令牌。

## 请求正文
<a name="API_GetBotAliases_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetBotAliases_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "BotAliases": [ 
      { 
         "botName": "string",
         "botVersion": "string",
         "checksum": "string",
         "conversationLogs": { 
            "iamRoleArn": "string",
            "logSettings": [ 
               { 
                  "destination": "string",
                  "kmsKeyArn": "string",
                  "logType": "string",
                  "resourceArn": "string",
                  "resourcePrefix": "string"
               }
            ]
         },
         "createdDate": number,
         "description": "string",
         "lastUpdatedDate": number,
         "name": "string"
      }
   ],
   "nextToken": "string"
}
```

## 响应元素
<a name="API_GetBotAliases_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [BotAliases](#API_GetBotAliases_ResponseSyntax) **   <a name="lex-GetBotAliases-response-BotAliases"></a>
`BotAliasMetadata` 对象数组，每个对象都描述一个机器人别名。  
类型：[BotAliasMetadata](API_BotAliasMetadata.md) 对象数组

 ** [nextToken](#API_GetBotAliases_ResponseSyntax) **   <a name="lex-GetBotAliases-response-nextToken"></a>
用于获取下一页别名的分页令牌。如果对此调用的响应被截断，Amazon Lex 将在响应中返回分页令牌。要获取下一页的别名，请在下一个请求中指定分页令牌。  
类型：字符串

## 错误
<a name="API_GetBotAliases_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

## 另请参阅
<a name="API_GetBotAliases_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBotAliases) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetBotAliases) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetBotAliases) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBotAliases) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetBotAliases) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetBotAliases) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetBotAliases) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBotAliases) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetBotAliases) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetBotAliases) 

# GetBotChannelAssociation
<a name="API_GetBotChannelAssociation"></a>

返回有关 Amazon Lex 机器人和消息收发平台之间的关联的信息。

此操作需要 `lex:GetBotChannelAssociation` 操作的权限。

## 请求语法
<a name="API_GetBotChannelAssociation_RequestSyntax"></a>

```
GET /bots/botName/aliases/aliasName/channels/name HTTP/1.1
```

## URI 请求参数
<a name="API_GetBotChannelAssociation_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [aliasName](#API_GetBotChannelAssociation_RequestSyntax) **   <a name="lex-GetBotChannelAssociation-request-uri-botAlias"></a>
指向要与之建立此关联的 Amazon Lex 机器人的特定版本的别名。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [botName](#API_GetBotChannelAssociation_RequestSyntax) **   <a name="lex-GetBotChannelAssociation-request-uri-botName"></a>
Amazon Lex 机器人的名称。  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [name](#API_GetBotChannelAssociation_RequestSyntax) **   <a name="lex-GetBotChannelAssociation-request-uri-name"></a>
机器人与通道之间的关联的名称。该名称区分大小写。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
必需：是

## 请求体
<a name="API_GetBotChannelAssociation_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetBotChannelAssociation_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "botAlias": "string",
   "botConfiguration": { 
      "string" : "string" 
   },
   "botName": "string",
   "createdDate": number,
   "description": "string",
   "failureReason": "string",
   "name": "string",
   "status": "string",
   "type": "string"
}
```

## 响应元素
<a name="API_GetBotChannelAssociation_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [botAlias](#API_GetBotChannelAssociation_ResponseSyntax) **   <a name="lex-GetBotChannelAssociation-response-botAlias"></a>
指向要与之建立此关联的 Amazon Lex 机器人的特定版本的别名。  
类型：字符串  
长度约束：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`

 ** [botConfiguration](#API_GetBotChannelAssociation_ResponseSyntax) **   <a name="lex-GetBotChannelAssociation-response-botConfiguration"></a>
提供消息收发平台与 Amazon Lex 通信所需的信息。  
类型：字符串到字符串映射  
映射条目：最多 10 项。

 ** [botName](#API_GetBotChannelAssociation_ResponseSyntax) **   <a name="lex-GetBotChannelAssociation-response-botName"></a>
Amazon Lex 机器人的名称。  
类型：字符串  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`

 ** [createdDate](#API_GetBotChannelAssociation_ResponseSyntax) **   <a name="lex-GetBotChannelAssociation-response-createdDate"></a>
机器人与通道之间建立关联的日期。  
类型：时间戳

 ** [description](#API_GetBotChannelAssociation_ResponseSyntax) **   <a name="lex-GetBotChannelAssociation-response-description"></a>
对机器人与通道之间关联的描述。  
类型：字符串  
长度限制：最小长度为 0。最大长度为 200。

 ** [failureReason](#API_GetBotChannelAssociation_ResponseSyntax) **   <a name="lex-GetBotChannelAssociation-response-failureReason"></a>
如果 `status` 是 `FAILED`，则 Amazon Lex 会提供其未能创建关联的原因。  
类型：字符串

 ** [name](#API_GetBotChannelAssociation_ResponseSyntax) **   <a name="lex-GetBotChannelAssociation-response-name"></a>
机器人与通道之间的关联的名称。  
类型：字符串  
长度约束：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`

 ** [status](#API_GetBotChannelAssociation_ResponseSyntax) **   <a name="lex-GetBotChannelAssociation-response-status"></a>
机器人通道的状态。  
+  `CREATED` — 通道已创建，随时可用。
+  `IN_PROGRESS` — 通道正在创建。
+  `FAILED` — 创建通道时出错。有关失败原因的信息，请参阅 `failureReason` 字段。
类型：字符串  
有效值：`IN_PROGRESS | CREATED | FAILED`

 ** [type](#API_GetBotChannelAssociation_ResponseSyntax) **   <a name="lex-GetBotChannelAssociation-response-type"></a>
消息收发平台的类型。  
类型：字符串  
有效值：`Facebook | Slack | Twilio-Sms | Kik`

## 错误
<a name="API_GetBotChannelAssociation_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_GetBotChannelAssociation_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBotChannelAssociation) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetBotChannelAssociation) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetBotChannelAssociation) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBotChannelAssociation) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetBotChannelAssociation) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetBotChannelAssociation) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetBotChannelAssociation) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBotChannelAssociation) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetBotChannelAssociation) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetBotChannelAssociation) 

# GetBotChannelAssociations
<a name="API_GetBotChannelAssociations"></a>

 返回与指定机器人关联的所有通道的列表。

`GetBotChannelAssociations` 操作需要 `lex:GetBotChannelAssociations` 操作的权限。

## 请求语法
<a name="API_GetBotChannelAssociations_RequestSyntax"></a>

```
GET /bots/botName/aliases/aliasName/channels/?maxResults=maxResults&nameContains=nameContains&nextToken=nextToken HTTP/1.1
```

## URI 请求参数
<a name="API_GetBotChannelAssociations_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [aliasName](#API_GetBotChannelAssociations_RequestSyntax) **   <a name="lex-GetBotChannelAssociations-request-uri-botAlias"></a>
指向要与之建立此关联的 Amazon Lex 机器人的特定版本的别名。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^(-|^([A-Za-z]_?)+$)$`  
是否必需：是

 ** [botName](#API_GetBotChannelAssociations_RequestSyntax) **   <a name="lex-GetBotChannelAssociations-request-uri-botName"></a>
关联中 Amazon Lex 机器人的名称。  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [maxResults](#API_GetBotChannelAssociations_RequestSyntax) **   <a name="lex-GetBotChannelAssociations-request-uri-maxResults"></a>
要在响应中返回的关联的最大数量。默认值为 50。  
有效范围：最小值为 1。最大值为 50。

 ** [nameContains](#API_GetBotChannelAssociations_RequestSyntax) **   <a name="lex-GetBotChannelAssociations-request-uri-nameContains"></a>
通道关联名称中要匹配的子字符串。如果关联名称的任何部分与子字符串匹配，则将返回关联。例如，“xyz”同时匹配“xyzabc”和“abcxyz”。要返回所有机器人通道关联，请使用连字符 ("-") 作为 `nameContains` 参数。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`

 ** [nextToken](#API_GetBotChannelAssociations_RequestSyntax) **   <a name="lex-GetBotChannelAssociations-request-uri-nextToken"></a>
用于获取下一页关联的分页令牌。如果对此调用的响应被截断，Amazon Lex 将在响应中返回分页令牌。要获取下一页关联，请在下一个请求中指定分页令牌。

## 请求正文
<a name="API_GetBotChannelAssociations_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetBotChannelAssociations_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "botChannelAssociations": [ 
      { 
         "botAlias": "string",
         "botConfiguration": { 
            "string" : "string" 
         },
         "botName": "string",
         "createdDate": number,
         "description": "string",
         "failureReason": "string",
         "name": "string",
         "status": "string",
         "type": "string"
      }
   ],
   "nextToken": "string"
}
```

## 响应元素
<a name="API_GetBotChannelAssociations_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [botChannelAssociations](#API_GetBotChannelAssociations_ResponseSyntax) **   <a name="lex-GetBotChannelAssociations-response-botChannelAssociations"></a>
对象数组，每个关联对应于一个对象，用于提供有关 Amazon Lex 机器人及其与通道关联的信息。  
类型：[BotChannelAssociation](API_BotChannelAssociation.md) 对象数组

 ** [nextToken](#API_GetBotChannelAssociations_ResponseSyntax) **   <a name="lex-GetBotChannelAssociations-response-nextToken"></a>
用于获取下一页关联的分页令牌。如果对此调用的响应被截断，Amazon Lex 将在响应中返回分页令牌。要获取下一页关联，请在下一个请求中指定分页令牌。  
类型：字符串

## 错误
<a name="API_GetBotChannelAssociations_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

## 另请参阅
<a name="API_GetBotChannelAssociations_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBotChannelAssociations) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetBotChannelAssociations) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetBotChannelAssociations) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBotChannelAssociations) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetBotChannelAssociations) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetBotChannelAssociations) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetBotChannelAssociations) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBotChannelAssociations) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetBotChannelAssociations) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetBotChannelAssociations) 

# GetBots
<a name="API_GetBots"></a>

返回机器人信息，如下所示：
+ 如果您提供 `nameContains` 字段，则响应将包含名称包含指定字符串的所有机器人的 `$LATEST` 版本信息。
+ 如果您未指定 `nameContains` 字段，则该操作将返回有关所有机器人的 `$LATEST` 版本的信息。

此操作需要 `lex:GetBots` 操作权限。

## 请求语法
<a name="API_GetBots_RequestSyntax"></a>

```
GET /bots/?maxResults=maxResults&nameContains=nameContains&nextToken=nextToken HTTP/1.1
```

## URI 请求参数
<a name="API_GetBots_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [maxResults](#API_GetBots_RequestSyntax) **   <a name="lex-GetBots-request-uri-maxResults"></a>
要在请求返回的响应中返回的机器人的最大数量。默认值为 10。  
有效范围：最小值为 1。最大值为 50。

 ** [nameContains](#API_GetBots_RequestSyntax) **   <a name="lex-GetBots-request-uri-nameContains"></a>
机器人名称中要匹配的子字符串。如果机器人名称的任何部分与子字符串匹配，则将返回机器人。例如，“xyz”同时匹配“xyzabc”和“abcxyz”。  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`

 ** [nextToken](#API_GetBots_RequestSyntax) **   <a name="lex-GetBots-request-uri-nextToken"></a>
用于获取下一页机器人的分页令牌。如果对此调用的响应被截断，Amazon Lex 将在响应中返回分页令牌。要获取下一页机器人，请在下一个请求中指定分页令牌。

## 请求正文
<a name="API_GetBots_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetBots_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "bots": [ 
      { 
         "createdDate": number,
         "description": "string",
         "lastUpdatedDate": number,
         "name": "string",
         "status": "string",
         "version": "string"
      }
   ],
   "nextToken": "string"
}
```

## 响应元素
<a name="API_GetBots_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [bots](#API_GetBots_ResponseSyntax) **   <a name="lex-GetBots-response-bots"></a>
`botMetadata` 对象数组，每个机器人对应一个条目。  
类型：[BotMetadata](API_BotMetadata.md) 对象数组

 ** [nextToken](#API_GetBots_ResponseSyntax) **   <a name="lex-GetBots-response-nextToken"></a>
如果响应被截断，它会包含一个分页令牌，您可以在下次请求中指定该令牌来获取下一页机器人。  
类型：字符串

## 错误
<a name="API_GetBots_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_GetBots_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBots) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetBots) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetBots) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBots) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetBots) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetBots) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetBots) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBots) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetBots) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetBots) 

# GetBotVersions
<a name="API_GetBotVersions"></a>

获取有关机器人的所有版本的信息。

`GetBotVersions` 操作会为每个版本的机器人返回一个 `BotMetadata` 对象。例如，如果机器人有三个带编号的版本，则 `GetBotVersions` 操作会在响应中返回四个 `BotMetadata` 对象，每个编号版本一个，`$LATEST` 版本一个。

`GetBotVersions` 操作始终返回至少一个版本，即 `$LATEST` 版本。

此操作需要 `lex:GetBotVersions` 操作的权限。

## 请求语法
<a name="API_GetBotVersions_RequestSyntax"></a>

```
GET /bots/name/versions/?maxResults=maxResults&nextToken=nextToken HTTP/1.1
```

## URI 请求参数
<a name="API_GetBotVersions_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [maxResults](#API_GetBotVersions_RequestSyntax) **   <a name="lex-GetBotVersions-request-uri-maxResults"></a>
要在一个响应中返回的机器人版本的最大数量。默认值为 10。  
有效范围：最小值为 1。最大值为 50。

 ** [name](#API_GetBotVersions_RequestSyntax) **   <a name="lex-GetBotVersions-request-uri-name"></a>
应返回其版本的自动程序的名称。  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [nextToken](#API_GetBotVersions_RequestSyntax) **   <a name="lex-GetBotVersions-request-uri-nextToken"></a>
用于获取下一页机器人版本的分页令牌。如果对此调用的响应被截断，Amazon Lex 将在响应中返回分页令牌。要获取下一页版本，请在下一个请求中指定分页令牌。

## 请求正文
<a name="API_GetBotVersions_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetBotVersions_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "bots": [ 
      { 
         "createdDate": number,
         "description": "string",
         "lastUpdatedDate": number,
         "name": "string",
         "status": "string",
         "version": "string"
      }
   ],
   "nextToken": "string"
}
```

## 响应元素
<a name="API_GetBotVersions_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [bots](#API_GetBotVersions_ResponseSyntax) **   <a name="lex-GetBotVersions-response-bots"></a>
`BotMetadata` 对象数组，每个编号的机器人版本各一个，`$LATEST` 版本一个。  
类型：[BotMetadata](API_BotMetadata.md) 对象数组

 ** [nextToken](#API_GetBotVersions_ResponseSyntax) **   <a name="lex-GetBotVersions-response-nextToken"></a>
用于获取下一页机器人版本的分页令牌。如果对此调用的响应被截断，Amazon Lex 将在响应中返回分页令牌。要获取下一页版本，请在下一个请求中指定分页令牌。  
类型：字符串

## 错误
<a name="API_GetBotVersions_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_GetBotVersions_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBotVersions) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetBotVersions) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetBotVersions) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBotVersions) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetBotVersions) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetBotVersions) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetBotVersions) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBotVersions) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetBotVersions) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetBotVersions) 

# GetBuiltinIntent
<a name="API_GetBuiltinIntent"></a>

返回有关内置目的的信息。

此操作需要 `lex:GetBuiltinIntent` 操作权限。

## 请求语法
<a name="API_GetBuiltinIntent_RequestSyntax"></a>

```
GET /builtins/intents/signature HTTP/1.1
```

## URI 请求参数
<a name="API_GetBuiltinIntent_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [signature](#API_GetBuiltinIntent_RequestSyntax) **   <a name="lex-GetBuiltinIntent-request-uri-signature"></a>
内置意图唯一标识符。要查找意图的签名，请参阅 *Alexa Skills Kit* 中的[标准内置意图](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/built-in-intent-ref/standard-intents)。  
是否必需：是

## 请求体
<a name="API_GetBuiltinIntent_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetBuiltinIntent_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "signature": "string",
   "slots": [ 
      { 
         "name": "string"
      }
   ],
   "supportedLocales": [ "string" ]
}
```

## 响应元素
<a name="API_GetBuiltinIntent_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [signature](#API_GetBuiltinIntent_ResponseSyntax) **   <a name="lex-GetBuiltinIntent-response-signature"></a>
内置意图唯一标识符。  
类型：字符串

 ** [slots](#API_GetBuiltinIntent_ResponseSyntax) **   <a name="lex-GetBuiltinIntent-response-slots"></a>
`BuiltinIntentSlot` 对象数组，意图中每种插槽类型对应一个条目。  
类型：[BuiltinIntentSlot](API_BuiltinIntentSlot.md) 对象数组

 ** [supportedLocales](#API_GetBuiltinIntent_ResponseSyntax) **   <a name="lex-GetBuiltinIntent-response-supportedLocales"></a>
意图支持的区域设置列表。  
类型：字符串数组  
有效值：`de-DE | en-AU | en-GB | en-IN | en-US | es-419 | es-ES | es-US | fr-FR | fr-CA | it-IT | ja-JP | ko-KR`

## 错误
<a name="API_GetBuiltinIntent_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_GetBuiltinIntent_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBuiltinIntent) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetBuiltinIntent) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetBuiltinIntent) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBuiltinIntent) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetBuiltinIntent) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetBuiltinIntent) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetBuiltinIntent) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBuiltinIntent) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetBuiltinIntent) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetBuiltinIntent) 

# GetBuiltinIntents
<a name="API_GetBuiltinIntents"></a>

获取符合指定条件的内置目的的列表。

此操作需要 `lex:GetBuiltinIntents` 操作权限。

## 请求语法
<a name="API_GetBuiltinIntents_RequestSyntax"></a>

```
GET /builtins/intents/?locale=locale&maxResults=maxResults&nextToken=nextToken&signatureContains=signatureContains HTTP/1.1
```

## URI 请求参数
<a name="API_GetBuiltinIntents_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [locale](#API_GetBuiltinIntents_RequestSyntax) **   <a name="lex-GetBuiltinIntents-request-uri-locale"></a>
意图支持的区域设置列表。  
有效值：`de-DE | en-AU | en-GB | en-IN | en-US | es-419 | es-ES | es-US | fr-FR | fr-CA | it-IT | ja-JP | ko-KR`

 ** [maxResults](#API_GetBuiltinIntents_RequestSyntax) **   <a name="lex-GetBuiltinIntents-request-uri-maxResults"></a>
要在响应中返回的意图的最大数量。默认值为 10。  
有效范围：最小值为 1。最大值为 50。

 ** [nextToken](#API_GetBuiltinIntents_RequestSyntax) **   <a name="lex-GetBuiltinIntents-request-uri-nextToken"></a>
用于获取下一页意图的分页令牌。如果此 API 调用被截断，Amazon Lex 将在响应中返回分页令牌。要获取下一页意图，请在下一个请求中使用分页令牌。

 ** [signatureContains](#API_GetBuiltinIntents_RequestSyntax) **   <a name="lex-GetBuiltinIntents-request-uri-signatureContains"></a>
内置意图签名中要匹配的子字符串。如果意图签名的任何部分与子字符串匹配，则将返回意图。例如，“xyz”同时匹配“xyzabc”和“abcxyz”。要查找意图的签名，请参阅 *Alexa Skills Kit* 中的[标准内置意图](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/built-in-intent-ref/standard-intents)。

## 请求正文
<a name="API_GetBuiltinIntents_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetBuiltinIntents_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "intents": [ 
      { 
         "signature": "string",
         "supportedLocales": [ "string" ]
      }
   ],
   "nextToken": "string"
}
```

## 响应元素
<a name="API_GetBuiltinIntents_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [intents](#API_GetBuiltinIntents_ResponseSyntax) **   <a name="lex-GetBuiltinIntents-response-intents"></a>
`builtinIntentMetadata` 对象数组，响应中的每个意图对应一个条目。  
类型：[BuiltinIntentMetadata](API_BuiltinIntentMetadata.md) 对象数组

 ** [nextToken](#API_GetBuiltinIntents_ResponseSyntax) **   <a name="lex-GetBuiltinIntents-response-nextToken"></a>
用于获取下一页意图的分页令牌。如果对此 API 调用的响应被截断，Amazon Lex 将在响应中返回分页令牌。要获取下一页意图，请在下一个请求中指定分页令牌。  
类型：字符串

## 错误
<a name="API_GetBuiltinIntents_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

## 另请参阅
<a name="API_GetBuiltinIntents_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBuiltinIntents) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetBuiltinIntents) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetBuiltinIntents) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBuiltinIntents) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetBuiltinIntents) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetBuiltinIntents) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetBuiltinIntents) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBuiltinIntents) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetBuiltinIntents) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetBuiltinIntents) 

# GetBuiltinSlotTypes
<a name="API_GetBuiltinSlotTypes"></a>

获取符合指定条件的内置槽类型的列表。

有关内置插槽类型的列表，请参阅 [Alexa Skills Kit](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/built-in-intent-ref/slot-type-reference) 中的*插槽类型参考*。

此操作需要 `lex:GetBuiltInSlotTypes` 操作权限。

## 请求语法
<a name="API_GetBuiltinSlotTypes_RequestSyntax"></a>

```
GET /builtins/slottypes/?locale=locale&maxResults=maxResults&nextToken=nextToken&signatureContains=signatureContains HTTP/1.1
```

## URI 请求参数
<a name="API_GetBuiltinSlotTypes_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [locale](#API_GetBuiltinSlotTypes_RequestSyntax) **   <a name="lex-GetBuiltinSlotTypes-request-uri-locale"></a>
插槽类型支持的区域设置列表。  
有效值：`de-DE | en-AU | en-GB | en-IN | en-US | es-419 | es-ES | es-US | fr-FR | fr-CA | it-IT | ja-JP | ko-KR`

 ** [maxResults](#API_GetBuiltinSlotTypes_RequestSyntax) **   <a name="lex-GetBuiltinSlotTypes-request-uri-maxResults"></a>
要在响应中返回的插槽类型的最大数量。默认值为 10。  
有效范围：最小值为 1。最大值为 50。

 ** [nextToken](#API_GetBuiltinSlotTypes_RequestSyntax) **   <a name="lex-GetBuiltinSlotTypes-request-uri-nextToken"></a>
用于获取下一页插槽类型的分页令牌。如果对此 API 调用的响应被截断，Amazon Lex 将在响应中返回分页令牌。要获取下一页插槽类型，请在下一个请求中指定分页令牌。

 ** [signatureContains](#API_GetBuiltinSlotTypes_RequestSyntax) **   <a name="lex-GetBuiltinSlotTypes-request-uri-signatureContains"></a>
内置插槽类型签名中要匹配的子字符串。如果插槽类型签名的任何部分与子字符串匹配，则将返回该插槽类型。例如，“xyz”同时匹配“xyzabc”和“abcxyz”。

## 请求正文
<a name="API_GetBuiltinSlotTypes_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetBuiltinSlotTypes_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "nextToken": "string",
   "slotTypes": [ 
      { 
         "signature": "string",
         "supportedLocales": [ "string" ]
      }
   ]
}
```

## 响应元素
<a name="API_GetBuiltinSlotTypes_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [nextToken](#API_GetBuiltinSlotTypes_ResponseSyntax) **   <a name="lex-GetBuiltinSlotTypes-response-nextToken"></a>
如果响应被截断，则响应中会包含一个分页令牌，您可以在下一个请求中使用该令牌来获取下一页插槽类型。  
类型：字符串

 ** [slotTypes](#API_GetBuiltinSlotTypes_ResponseSyntax) **   <a name="lex-GetBuiltinSlotTypes-response-slotTypes"></a>
`BuiltInSlotTypeMetadata` 对象数组，返回的每种插槽类型对应一个条目。  
类型：[BuiltinSlotTypeMetadata](API_BuiltinSlotTypeMetadata.md) 对象数组

## 错误
<a name="API_GetBuiltinSlotTypes_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

## 另请参阅
<a name="API_GetBuiltinSlotTypes_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBuiltinSlotTypes) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetBuiltinSlotTypes) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetBuiltinSlotTypes) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBuiltinSlotTypes) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetBuiltinSlotTypes) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetBuiltinSlotTypes) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetBuiltinSlotTypes) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBuiltinSlotTypes) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetBuiltinSlotTypes) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetBuiltinSlotTypes) 

# GetExport
<a name="API_GetExport"></a>

以指定格式导出 Amazon Lex 资源的内容。

## 请求语法
<a name="API_GetExport_RequestSyntax"></a>

```
GET /exports/?exportType=exportType&name=name&resourceType=resourceType&version=version HTTP/1.1
```

## URI 请求参数
<a name="API_GetExport_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [exportType](#API_GetExport_RequestSyntax) **   <a name="lex-GetExport-request-uri-exportType"></a>
导出的数据的格式。  
有效值：`ALEXA_SKILLS_KIT | LEX`  
是否必需：是

 ** [name](#API_GetExport_RequestSyntax) **   <a name="lex-GetExport-request-uri-name"></a>
要导出的机器人的名称。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`[a-zA-Z_]+`  
是否必需：是

 ** [resourceType](#API_GetExport_RequestSyntax) **   <a name="lex-GetExport-request-uri-resourceType"></a>
要导出的资源的类型。  
有效值：`BOT | INTENT | SLOT_TYPE`  
是否必需：是

 ** [version](#API_GetExport_RequestSyntax) **   <a name="lex-GetExport-request-uri-version"></a>
要导出的机器人的版本。  
长度限制：最小长度为 1。长度上限为 64。  
模式：`[0-9]+`  
必需：是

## 请求体
<a name="API_GetExport_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetExport_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "exportStatus": "string",
   "exportType": "string",
   "failureReason": "string",
   "name": "string",
   "resourceType": "string",
   "url": "string",
   "version": "string"
}
```

## 响应元素
<a name="API_GetExport_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [exportStatus](#API_GetExport_ResponseSyntax) **   <a name="lex-GetExport-response-exportStatus"></a>
导出的状态。  
+  `IN_PROGRESS` — 正在导出。
+  `READY` — 导出已完成。
+  `FAILED` — 无法完成导出。
类型：字符串  
有效值：`IN_PROGRESS | READY | FAILED`

 ** [exportType](#API_GetExport_ResponseSyntax) **   <a name="lex-GetExport-response-exportType"></a>
导出的数据的格式。  
类型：字符串  
有效值：`ALEXA_SKILLS_KIT | LEX`

 ** [failureReason](#API_GetExport_ResponseSyntax) **   <a name="lex-GetExport-response-failureReason"></a>
如果 `status` 是 `FAILED`，则 Amazon Lex 会提供其未能导出资源的原因。  
类型：字符串

 ** [name](#API_GetExport_ResponseSyntax) **   <a name="lex-GetExport-response-name"></a>
正在导出的机器人的名称。  
类型：字符串  
长度约束：最小长度为 1。最大长度为 100。  
模式：`[a-zA-Z_]+`

 ** [resourceType](#API_GetExport_ResponseSyntax) **   <a name="lex-GetExport-response-resourceType"></a>
已导出的资源的类型。  
类型：字符串  
有效值：`BOT | INTENT | SLOT_TYPE`

 ** [url](#API_GetExport_ResponseSyntax) **   <a name="lex-GetExport-response-url"></a>
提供已导出的资源位置的 S3 预签名 URL。已导出的资源是包含 JSON 格式的已导出资源的 ZIP 存档。存档的结构可能会发生变化。您的代码不应依赖于存档结构。  
类型：字符串

 ** [version](#API_GetExport_ResponseSyntax) **   <a name="lex-GetExport-response-version"></a>
正在导出的机器人的版本。  
类型：字符串  
长度限制：最小长度为 1。长度上限为 64。  
模式：`[0-9]+`

## 错误
<a name="API_GetExport_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_GetExport_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetExport) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetExport) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetExport) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetExport) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetExport) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetExport) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetExport) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetExport) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetExport) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetExport) 

# GetImport
<a name="API_GetImport"></a>

获取有关使用 `StartImport` 操作启动的导入作业的信息。

## 请求语法
<a name="API_GetImport_RequestSyntax"></a>

```
GET /imports/importId HTTP/1.1
```

## URI 请求参数
<a name="API_GetImport_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [importId](#API_GetImport_RequestSyntax) **   <a name="lex-GetImport-request-uri-importId"></a>
要返回的导入作业信息的标识符。  
是否必需：是

## 请求体
<a name="API_GetImport_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetImport_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "createdDate": number,
   "failureReason": [ "string" ],
   "importId": "string",
   "importStatus": "string",
   "mergeStrategy": "string",
   "name": "string",
   "resourceType": "string"
}
```

## 响应元素
<a name="API_GetImport_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [createdDate](#API_GetImport_ResponseSyntax) **   <a name="lex-GetImport-response-createdDate"></a>
创建导入作业的日期和时间的时间戳。  
类型：时间戳

 ** [failureReason](#API_GetImport_ResponseSyntax) **   <a name="lex-GetImport-response-failureReason"></a>
描述导入作业未能完成的原因的字符串。  
类型：字符串数组

 ** [importId](#API_GetImport_ResponseSyntax) **   <a name="lex-GetImport-response-importId"></a>
特定导入作业的标识符。  
类型：字符串

 ** [importStatus](#API_GetImport_ResponseSyntax) **   <a name="lex-GetImport-response-importStatus"></a>
导入作业的状态。如果状态为 `FAILED`，则可以从 `failureReason` 字段获取失败的原因。  
类型：字符串  
有效值：`IN_PROGRESS | COMPLETE | FAILED`

 ** [mergeStrategy](#API_GetImport_ResponseSyntax) **   <a name="lex-GetImport-response-mergeStrategy"></a>
现有资源与导入文件中的资源发生冲突时采取的操作。  
类型：字符串  
有效值：`OVERWRITE_LATEST | FAIL_ON_CONFLICT`

 ** [name](#API_GetImport_ResponseSyntax) **   <a name="lex-GetImport-response-name"></a>
提供给导入作业的名称。  
类型：字符串  
长度约束：最小长度为 1。最大长度为 100。  
模式：`[a-zA-Z_]+`

 ** [resourceType](#API_GetImport_ResponseSyntax) **   <a name="lex-GetImport-response-resourceType"></a>
已导入的资源的类型。  
类型：字符串  
有效值：`BOT | INTENT | SLOT_TYPE`

## 错误
<a name="API_GetImport_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_GetImport_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetImport) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetImport) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetImport) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetImport) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetImport) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetImport) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetImport) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetImport) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetImport) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetImport) 

# GetIntent
<a name="API_GetIntent"></a>

 返回有关意图的信息。除了意图名称外，您还必须指定意图版本。

 此操作需要执行 `lex:GetIntent` 操作的权限。

## 请求语法
<a name="API_GetIntent_RequestSyntax"></a>

```
GET /intents/name/versions/version HTTP/1.1
```

## URI 请求参数
<a name="API_GetIntent_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [name](#API_GetIntent_RequestSyntax) **   <a name="lex-GetIntent-request-uri-name"></a>
意图的名称。该名称区分大小写。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [version](#API_GetIntent_RequestSyntax) **   <a name="lex-GetIntent-request-uri-version"></a>
意图的版本。  
长度限制：最小长度为 1。长度上限为 64。  
模式：`\$LATEST|[0-9]+`  
必需：是

## 请求体
<a name="API_GetIntent_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetIntent_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "checksum": "string",
   "conclusionStatement": { 
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "confirmationPrompt": { 
      "maxAttempts": number,
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "createdDate": number,
   "description": "string",
   "dialogCodeHook": { 
      "messageVersion": "string",
      "uri": "string"
   },
   "followUpPrompt": { 
      "prompt": { 
         "maxAttempts": number,
         "messages": [ 
            { 
               "content": "string",
               "contentType": "string",
               "groupNumber": number
            }
         ],
         "responseCard": "string"
      },
      "rejectionStatement": { 
         "messages": [ 
            { 
               "content": "string",
               "contentType": "string",
               "groupNumber": number
            }
         ],
         "responseCard": "string"
      }
   },
   "fulfillmentActivity": { 
      "codeHook": { 
         "messageVersion": "string",
         "uri": "string"
      },
      "type": "string"
   },
   "inputContexts": [ 
      { 
         "name": "string"
      }
   ],
   "kendraConfiguration": { 
      "kendraIndex": "string",
      "queryFilterString": "string",
      "role": "string"
   },
   "lastUpdatedDate": number,
   "name": "string",
   "outputContexts": [ 
      { 
         "name": "string",
         "timeToLiveInSeconds": number,
         "turnsToLive": number
      }
   ],
   "parentIntentSignature": "string",
   "rejectionStatement": { 
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "sampleUtterances": [ "string" ],
   "slots": [ 
      { 
         "defaultValueSpec": { 
            "defaultValueList": [ 
               { 
                  "defaultValue": "string"
               }
            ]
         },
         "description": "string",
         "name": "string",
         "obfuscationSetting": "string",
         "priority": number,
         "responseCard": "string",
         "sampleUtterances": [ "string" ],
         "slotConstraint": "string",
         "slotType": "string",
         "slotTypeVersion": "string",
         "valueElicitationPrompt": { 
            "maxAttempts": number,
            "messages": [ 
               { 
                  "content": "string",
                  "contentType": "string",
                  "groupNumber": number
               }
            ],
            "responseCard": "string"
         }
      }
   ],
   "version": "string"
}
```

## 响应元素
<a name="API_GetIntent_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [checksum](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-checksum"></a>
意图的校验和。  
类型：字符串

 ** [conclusionStatement](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-conclusionStatement"></a>
在 `fulfillmentActivity` 元素中指定的 Lambda 函数履行意图后，Amazon Lex 会将此语句传达给用户。  
类型：[Statement](API_Statement.md) 对象

 ** [confirmationPrompt](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-confirmationPrompt"></a>
如果在机器人中已定义，则 Amazon Lex 会在履行用户请求之前使用提示确认意图。有关更多信息，请参阅 [PutIntent](API_PutIntent.md)。  
类型：[Prompt](API_Prompt.md) 对象

 ** [createdDate](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-createdDate"></a>
意图的创建日期。  
类型：时间戳

 ** [description](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-description"></a>
目的的描述。  
类型：字符串  
长度限制：最小长度为 0。最大长度为 200。

 ** [dialogCodeHook](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-dialogCodeHook"></a>
如果已在机器人中定则 义，则 Amazon Lex 会为每个用户输入调用此 Lambda 函数。有关更多信息，请参阅 [PutIntent](API_PutIntent.md)。  
类型：[CodeHook](API_CodeHook.md) 对象

 ** [followUpPrompt](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-followUpPrompt"></a>
如果已在机器人中定义，则 Amazon Lex 会在履行意图后使用此提示来征求其他用户活动。有关更多信息，请参阅 [PutIntent](API_PutIntent.md)。  
类型：[FollowUpPrompt](API_FollowUpPrompt.md) 对象

 ** [fulfillmentActivity](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-fulfillmentActivity"></a>
描述履行意图的方式。有关更多信息，请参阅 [PutIntent](API_PutIntent.md)。  
类型：[FulfillmentActivity](API_FulfillmentActivity.md) 对象

 ** [inputContexts](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-inputContexts"></a>
`InputContext` 对象数组，列出了 Amazon Lex 在与用户的对话中选择意图时必须处于活动状态的上下文。  
类型：[InputContext](API_InputContext.md) 对象数组  
数组成员：最少 0 个物品。最多 5 项。

 ** [kendraConfiguration](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-kendraConfiguration"></a>
用于将 Amazon Kendra 索引与 `AMAZON.KendraSearchIntent` 意图关联的配置信息（如果有）。  
类型：[KendraConfiguration](API_KendraConfiguration.md) 对象

 ** [lastUpdatedDate](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-lastUpdatedDate"></a>
意图的更新日期。创建资源时，创建日期和上次更新日期相同。  
类型：时间戳

 ** [name](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-name"></a>
意图的名称。  
类型：字符串  
长度约束：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`

 ** [outputContexts](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-outputContexts"></a>
`OutputContext` 对象数组，列出了履行意图时意图激活的上下文。  
类型：[OutputContext](API_OutputContext.md) 对象数组  
数组成员：最少 0 个物品。最多 10 个物品。

 ** [parentIntentSignature](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-parentIntentSignature"></a>
内置意图唯一标识符。  
类型：字符串

 ** [rejectionStatement](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-rejectionStatement"></a>
当用户对 `confirmationPrompt` 中定义的问题回答“否”时，Amazon Lex 将使用此语句进行响应，以确认意图已被取消。  
类型：[Statement](API_Statement.md) 对象

 ** [sampleUtterances](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-sampleUtterances"></a>
为意图配置的示例言语数组。  
类型：字符串数组  
数组成员：最少 0 项。最多 1500 项。  
长度限制：最小长度为 1。最大长度为 200。

 ** [slots](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-slots"></a>
为意图配置的意图插槽数组。  
类型：[Slot](API_Slot.md) 对象数组  
数组成员：最少 0 个物品。最多 100 个项目。

 ** [version](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-version"></a>
意图的版本。  
类型：字符串  
长度限制：最小长度为 1。长度上限为 64。  
模式：`\$LATEST|[0-9]+`

## 错误
<a name="API_GetIntent_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_GetIntent_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetIntent) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetIntent) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetIntent) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetIntent) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetIntent) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetIntent) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetIntent) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetIntent) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetIntent) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetIntent) 

# GetIntents
<a name="API_GetIntents"></a>

返回意图信息，如下所示：
+ 如果指定 `nameContains` 字段，则返回包含指定字符串的所有意图的 `$LATEST` 版本。
+  如果未指定 `nameContains` 字段，则返回有关所有意图的 `$LATEST` 版本的信息。

 该操作需要 `lex:GetIntents` 操作的权限。

## 请求语法
<a name="API_GetIntents_RequestSyntax"></a>

```
GET /intents/?maxResults=maxResults&nameContains=nameContains&nextToken=nextToken HTTP/1.1
```

## URI 请求参数
<a name="API_GetIntents_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [maxResults](#API_GetIntents_RequestSyntax) **   <a name="lex-GetIntents-request-uri-maxResults"></a>
要在响应中返回的意图的最大数量。默认值为 10。  
有效范围：最小值为 1。最大值为 50。

 ** [nameContains](#API_GetIntents_RequestSyntax) **   <a name="lex-GetIntents-request-uri-nameContains"></a>
意图名称中要匹配的子字符串。如果意图名称的任何部分与子字符串匹配，则将返回意图。例如，“xyz”同时匹配“xyzabc”和“abcxyz”。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`

 ** [nextToken](#API_GetIntents_RequestSyntax) **   <a name="lex-GetIntents-request-uri-nextToken"></a>
用于获取下一页意图的分页令牌。如果对此 API 调用的响应被截断，Amazon Lex 将在响应中返回分页令牌。要获取下一页意图，请在下一个请求中指定分页令牌。

## 请求正文
<a name="API_GetIntents_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetIntents_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "intents": [ 
      { 
         "createdDate": number,
         "description": "string",
         "lastUpdatedDate": number,
         "name": "string",
         "version": "string"
      }
   ],
   "nextToken": "string"
}
```

## 响应元素
<a name="API_GetIntents_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [intents](#API_GetIntents_ResponseSyntax) **   <a name="lex-GetIntents-response-intents"></a>
`Intent` 数据元数组。有关更多信息，请参阅 [PutBot](API_PutBot.md)。  
类型：[IntentMetadata](API_IntentMetadata.md) 对象数组

 ** [nextToken](#API_GetIntents_ResponseSyntax) **   <a name="lex-GetIntents-response-nextToken"></a>
如果响应被截断，则响应会包含一个分页令牌，您可以在下次请求中指定该令牌来获取下一页意图。  
类型：字符串

## 错误
<a name="API_GetIntents_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_GetIntents_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetIntents) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetIntents) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetIntents) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetIntents) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetIntents) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetIntents) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetIntents) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetIntents) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetIntents) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetIntents) 

# GetIntentVersions
<a name="API_GetIntentVersions"></a>

获取有关意图的所有版本的信息。

`GetIntentVersions` 操作会为每个版本的意图返回一个 `IntentMetadata` 对象。例如，如果意图有三个带编号的版本，则 `GetIntentVersions` 操作会在响应中返回四个 `IntentMetadata` 对象，每个编号版本一个，`$LATEST` 版本一个。

`GetIntentVersions` 操作始终返回至少一个版本，即 `$LATEST` 版本。

此操作需要 `lex:GetIntentVersions` 操作的权限。

## 请求语法
<a name="API_GetIntentVersions_RequestSyntax"></a>

```
GET /intents/name/versions/?maxResults=maxResults&nextToken=nextToken HTTP/1.1
```

## URI 请求参数
<a name="API_GetIntentVersions_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [maxResults](#API_GetIntentVersions_RequestSyntax) **   <a name="lex-GetIntentVersions-request-uri-maxResults"></a>
要在一个响应中返回的意图版本的最大数量。默认值为 10。  
有效范围：最小值为 1。最大值为 50。

 ** [name](#API_GetIntentVersions_RequestSyntax) **   <a name="lex-GetIntentVersions-request-uri-name"></a>
应返回其版本的意图的名称。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [nextToken](#API_GetIntentVersions_RequestSyntax) **   <a name="lex-GetIntentVersions-request-uri-nextToken"></a>
用于获取下一页意图版本的分页令牌。如果对此调用的响应被截断，Amazon Lex 将在响应中返回分页令牌。要获取下一页版本，请在下一个请求中指定分页令牌。

## 请求正文
<a name="API_GetIntentVersions_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetIntentVersions_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "intents": [ 
      { 
         "createdDate": number,
         "description": "string",
         "lastUpdatedDate": number,
         "name": "string",
         "version": "string"
      }
   ],
   "nextToken": "string"
}
```

## 响应元素
<a name="API_GetIntentVersions_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [intents](#API_GetIntentVersions_ResponseSyntax) **   <a name="lex-GetIntentVersions-response-intents"></a>
`IntentMetadata` 对象数组，每个编号的意图版本各一个，`$LATEST` 版本一个。  
类型：[IntentMetadata](API_IntentMetadata.md) 对象数组

 ** [nextToken](#API_GetIntentVersions_ResponseSyntax) **   <a name="lex-GetIntentVersions-response-nextToken"></a>
用于获取下一页意图版本的分页令牌。如果对此调用的响应被截断，Amazon Lex 将在响应中返回分页令牌。要获取下一页版本，请在下一个请求中指定分页令牌。  
类型：字符串

## 错误
<a name="API_GetIntentVersions_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_GetIntentVersions_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetIntentVersions) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetIntentVersions) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetIntentVersions) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetIntentVersions) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetIntentVersions) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetIntentVersions) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetIntentVersions) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetIntentVersions) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetIntentVersions) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetIntentVersions) 

# GetMigration
<a name="API_GetMigration"></a>

提供有关从 Amazon Lex V1 机器人到 Amazon Lex V2 机器人的持续或完整迁移的详细信息。使用此操作可查看与迁移相关的迁移警报和警告。

## 请求语法
<a name="API_GetMigration_RequestSyntax"></a>

```
GET /migrations/migrationId HTTP/1.1
```

## URI 请求参数
<a name="API_GetMigration_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [migrationId](#API_GetMigration_RequestSyntax) **   <a name="lex-GetMigration-request-uri-migrationId"></a>
要查看的迁移的唯一标识符。由 [StartMigration](API_StartMigration.md) 操作返回 `migrationID`。  
长度限制：固定长度为 10。  
模式：`^[0-9a-zA-Z]+$`  
必需：是

## 请求体
<a name="API_GetMigration_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetMigration_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "alerts": [ 
      { 
         "details": [ "string" ],
         "message": "string",
         "referenceURLs": [ "string" ],
         "type": "string"
      }
   ],
   "migrationId": "string",
   "migrationStatus": "string",
   "migrationStrategy": "string",
   "migrationTimestamp": number,
   "v1BotLocale": "string",
   "v1BotName": "string",
   "v1BotVersion": "string",
   "v2BotId": "string",
   "v2BotRole": "string"
}
```

## 响应元素
<a name="API_GetMigration_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [alerts](#API_GetMigration_ResponseSyntax) **   <a name="lex-GetMigration-response-alerts"></a>
警报和警告列表，这些警报和警告表明 Amazon Lex V1 机器人迁移到 Amazon Lex V2 时存在问题。当 Amazon Lex V1 功能在 Amazon Lex V2 中有不同的实现方式时，您会收到警告。  
有关更多信息，请参阅**《Amazon Lex V2 开发人员指南》中的[迁移机器人](https://docs.aws.amazon.com/lexv2/latest/dg/migrate.html)。  
类型：[MigrationAlert](API_MigrationAlert.md) 对象数组

 ** [migrationId](#API_GetMigration_ResponseSyntax) **   <a name="lex-GetMigration-response-migrationId"></a>
迁移的唯一标识符。这与调用 `GetMigration` 操作时使用的标识符相同。  
类型：字符串  
长度限制：固定长度为 10。  
模式：`^[0-9a-zA-Z]+$`

 ** [migrationStatus](#API_GetMigration_ResponseSyntax) **   <a name="lex-GetMigration-response-migrationStatus"></a>
表示迁移的状态。当迁移完成并且机器人在 Amazon Lex V2 中可用时，状态为 `COMPLETE`。可能需要解决警报和警告才能完成迁移。  
类型：字符串  
有效值：`IN_PROGRESS | COMPLETED | FAILED`

 ** [migrationStrategy](#API_GetMigration_ResponseSyntax) **   <a name="lex-GetMigration-response-migrationStrategy"></a>
用于进行迁移的策略。  
+  `CREATE_NEW` — 创建新的 Amazon Lex V2 机器人并将 Amazon Lex V1 机器人迁移到新机器人。
+  `UPDATE_EXISTING` — 覆盖现有的 Amazon Lex V2 机器人元数据和正在迁移的区域设置。它不会更改 Amazon Lex V2 机器人中的任何其他区域设置。如果该区域设置不存在，则会在 Amazon Lex V2 机器人中创建一个新的区域设置。
类型：字符串  
有效值：`CREATE_NEW | UPDATE_EXISTING`

 ** [migrationTimestamp](#API_GetMigration_ResponseSyntax) **   <a name="lex-GetMigration-response-migrationTimestamp"></a>
启动迁移的日期和时间。  
类型：时间戳

 ** [v1BotLocale](#API_GetMigration_ResponseSyntax) **   <a name="lex-GetMigration-response-v1BotLocale"></a>
已迁移到 Amazon Lex V2 的 Amazon Lex V1 机器人的区域设置。  
类型：字符串  
有效值：`de-DE | en-AU | en-GB | en-IN | en-US | es-419 | es-ES | es-US | fr-FR | fr-CA | it-IT | ja-JP | ko-KR`

 ** [v1BotName](#API_GetMigration_ResponseSyntax) **   <a name="lex-GetMigration-response-v1BotName"></a>
已迁移到 Amazon Lex V2 的 Amazon Lex V1 机器人的名称。  
类型：字符串  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`

 ** [v1BotVersion](#API_GetMigration_ResponseSyntax) **   <a name="lex-GetMigration-response-v1BotVersion"></a>
已迁移到 Amazon Lex V2 的 Amazon Lex V1 机器人的版本。  
类型：字符串  
长度限制：最小长度为 1。长度上限为 64。  
模式：`\$LATEST|[0-9]+`

 ** [v2BotId](#API_GetMigration_ResponseSyntax) **   <a name="lex-GetMigration-response-v2BotId"></a>
Amazon Lex V1 要迁移到的 Amazon Lex V2 机器人的唯一标识符。  
类型：字符串  
长度限制：固定长度为 10。  
模式：`^[0-9a-zA-Z]+$`

 ** [v2BotRole](#API_GetMigration_ResponseSyntax) **   <a name="lex-GetMigration-response-v2BotRole"></a>
Amazon Lex 用来运行 Amazon Lex V2 机器人的 IAM 角色。  
类型：字符串  
长度约束：最小长度为 20。最大长度为 2048。  
模式：`^arn:[\w\-]+:iam::[\d]{12}:role/.+$`

## 错误
<a name="API_GetMigration_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_GetMigration_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetMigration) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetMigration) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetMigration) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetMigration) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetMigration) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetMigration) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetMigration) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetMigration) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetMigration) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetMigration) 

# GetMigrations
<a name="API_GetMigrations"></a>

获取 Amazon Lex V1 和 Amazon Lex V2 之间的迁移列表。

## 请求语法
<a name="API_GetMigrations_RequestSyntax"></a>

```
GET /migrations?maxResults=maxResults&migrationStatusEquals=migrationStatusEquals&nextToken=nextToken&sortByAttribute=sortByAttribute&sortByOrder=sortByOrder&v1BotNameContains=v1BotNameContains HTTP/1.1
```

## URI 请求参数
<a name="API_GetMigrations_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [maxResults](#API_GetMigrations_RequestSyntax) **   <a name="lex-GetMigrations-request-uri-maxResults"></a>
要在响应中返回的迁移的最大数量。默认值为 10。  
有效范围：最小值为 1。最大值为 50。

 ** [migrationStatusEquals](#API_GetMigrations_RequestSyntax) **   <a name="lex-GetMigrations-request-uri-migrationStatusEquals"></a>
筛选列表以仅包含处于指定状态的迁移。  
有效值：`IN_PROGRESS | COMPLETED | FAILED`

 ** [nextToken](#API_GetMigrations_RequestSyntax) **   <a name="lex-GetMigrations-request-uri-nextToken"></a>
用于获取下一页迁移的分页令牌。如果对此操作的响应被截断，Amazon Lex 将在响应中返回分页令牌。要获取下一页迁移，请在下一个请求中指定分页令牌。

 ** [sortByAttribute](#API_GetMigrations_RequestSyntax) **   <a name="lex-GetMigrations-request-uri-sortByAttribute"></a>
用于对迁移列表进行排序的字段。您可以按照 Amazon Lex V1 机器人名称或开始迁移的日期和时间进行排序。  
有效值：`V1_BOT_NAME | MIGRATION_DATE_TIME`

 ** [sortByOrder](#API_GetMigrations_RequestSyntax) **   <a name="lex-GetMigrations-request-uri-sortByOrder"></a>
对列表进行排序的顺序。  
有效值：`ASCENDING | DESCENDING`

 ** [v1BotNameContains](#API_GetMigrations_RequestSyntax) **   <a name="lex-GetMigrations-request-uri-v1BotNameContains"></a>
筛选列表以仅包含名称包含指定字符串的机器人。该字符串与机器人名称中的任意位置匹配。  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`

## 请求正文
<a name="API_GetMigrations_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetMigrations_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "migrationSummaries": [ 
      { 
         "migrationId": "string",
         "migrationStatus": "string",
         "migrationStrategy": "string",
         "migrationTimestamp": number,
         "v1BotLocale": "string",
         "v1BotName": "string",
         "v1BotVersion": "string",
         "v2BotId": "string",
         "v2BotRole": "string"
      }
   ],
   "nextToken": "string"
}
```

## 响应元素
<a name="API_GetMigrations_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [migrationSummaries](#API_GetMigrations_ResponseSyntax) **   <a name="lex-GetMigrations-response-migrationSummaries"></a>
从 Amazon Lex V1 迁移到 Amazon Lex V2 的一系列摘要。要查看迁移的详细信息，请使用对 [GetMigration](API_GetMigration.md) 操作的调用的摘要中的 `migrationId`。  
类型：[MigrationSummary](API_MigrationSummary.md) 对象数组

 ** [nextToken](#API_GetMigrations_ResponseSyntax) **   <a name="lex-GetMigrations-response-nextToken"></a>
如果响应被截断，它会包含一个分页令牌，您可以在下一个请求中指定该令牌来获取下一页迁移。  
类型：字符串

## 错误
<a name="API_GetMigrations_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

## 另请参阅
<a name="API_GetMigrations_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetMigrations) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetMigrations) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetMigrations) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetMigrations) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetMigrations) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetMigrations) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetMigrations) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetMigrations) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetMigrations) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetMigrations) 

# GetSlotType
<a name="API_GetSlotType"></a>

返回有关槽类型的特定版本的信息。除了指定插槽类型名称外，您还必须指定插槽类型版本。

此操作需要 `lex:GetSlotType` 操作的权限。

## 请求语法
<a name="API_GetSlotType_RequestSyntax"></a>

```
GET /slottypes/name/versions/version HTTP/1.1
```

## URI 请求参数
<a name="API_GetSlotType_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [name](#API_GetSlotType_RequestSyntax) **   <a name="lex-GetSlotType-request-uri-name"></a>
槽类型的名称。该名称区分大小写。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [version](#API_GetSlotType_RequestSyntax) **   <a name="lex-GetSlotType-request-uri-version"></a>
插槽类型的版本。  
长度限制：最小长度为 1。长度上限为 64。  
模式：`\$LATEST|[0-9]+`  
必需：是

## 请求体
<a name="API_GetSlotType_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetSlotType_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "checksum": "string",
   "createdDate": number,
   "description": "string",
   "enumerationValues": [ 
      { 
         "synonyms": [ "string" ],
         "value": "string"
      }
   ],
   "lastUpdatedDate": number,
   "name": "string",
   "parentSlotTypeSignature": "string",
   "slotTypeConfigurations": [ 
      { 
         "regexConfiguration": { 
            "pattern": "string"
         }
      }
   ],
   "valueSelectionStrategy": "string",
   "version": "string"
}
```

## 响应元素
<a name="API_GetSlotType_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [checksum](#API_GetSlotType_ResponseSyntax) **   <a name="lex-GetSlotType-response-checksum"></a>
插槽类型的 `$LATEST` 版本的校验和。  
类型：字符串

 ** [createdDate](#API_GetSlotType_ResponseSyntax) **   <a name="lex-GetSlotType-response-createdDate"></a>
插槽类型的创建日期。  
类型：时间戳

 ** [description](#API_GetSlotType_ResponseSyntax) **   <a name="lex-GetSlotType-response-description"></a>
槽类型的描述。  
类型：字符串  
长度限制：最小长度为 0。最大长度为 200。

 ** [enumerationValues](#API_GetSlotType_ResponseSyntax) **   <a name="lex-GetSlotType-response-enumerationValues"></a>
定义插槽类型可采用值的 `EnumerationValue` 对象的列表。  
类型：[EnumerationValue](API_EnumerationValue.md) 对象数组  
数组成员：最少 0 个物品。最多 10000 项。

 ** [lastUpdatedDate](#API_GetSlotType_ResponseSyntax) **   <a name="lex-GetSlotType-response-lastUpdatedDate"></a>
插槽类型的更新日期。创建资源时，创建日期和上次更新日期相同。  
类型：时间戳

 ** [name](#API_GetSlotType_ResponseSyntax) **   <a name="lex-GetSlotType-response-name"></a>
槽类型的名称。  
类型：字符串  
长度约束：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`

 ** [parentSlotTypeSignature](#API_GetSlotType_ResponseSyntax) **   <a name="lex-GetSlotType-response-parentSlotTypeSignature"></a>
用作此插槽类型的父级的内置插槽类型。  
类型：字符串  
长度约束：最小长度为 1。最大长度为 100。  
模式：`^((AMAZON\.)_?|[A-Za-z]_?)+`

 ** [slotTypeConfigurations](#API_GetSlotType_ResponseSyntax) **   <a name="lex-GetSlotType-response-slotTypeConfigurations"></a>
扩展父级内置插槽类型的配置信息。  
类型：[SlotTypeConfiguration](API_SlotTypeConfiguration.md) 对象数组  
数组成员：最少 0 个物品。最多 10 个物品。

 ** [valueSelectionStrategy](#API_GetSlotType_ResponseSyntax) **   <a name="lex-GetSlotType-response-valueSelectionStrategy"></a>
Amazon Lex 用来确定插槽的值的策略。有关更多信息，请参阅 [PutSlotType](API_PutSlotType.md)。  
类型：字符串  
有效值：`ORIGINAL_VALUE | TOP_RESOLUTION`

 ** [version](#API_GetSlotType_ResponseSyntax) **   <a name="lex-GetSlotType-response-version"></a>
插槽类型的版本。  
类型：字符串  
长度限制：最小长度为 1。长度上限为 64。  
模式：`\$LATEST|[0-9]+`

## 错误
<a name="API_GetSlotType_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_GetSlotType_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetSlotType) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetSlotType) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetSlotType) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetSlotType) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetSlotType) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetSlotType) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetSlotType) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetSlotType) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetSlotType) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetSlotType) 

# GetSlotTypes
<a name="API_GetSlotTypes"></a>

返回插槽类型信息，如下所示：
+ 如果指定 `nameContains` 字段，则返回包含指定字符串的所有插槽类型的 `$LATEST` 版本。
+  如果未指定 `nameContains` 字段，则返回有关所有插槽类型的 `$LATEST` 版本的信息。

 该操作需要 `lex:GetSlotTypes` 操作的权限。

## 请求语法
<a name="API_GetSlotTypes_RequestSyntax"></a>

```
GET /slottypes/?maxResults=maxResults&nameContains=nameContains&nextToken=nextToken HTTP/1.1
```

## URI 请求参数
<a name="API_GetSlotTypes_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [maxResults](#API_GetSlotTypes_RequestSyntax) **   <a name="lex-GetSlotTypes-request-uri-maxResults"></a>
要在响应中返回的插槽类型的最大数量。默认值为 10。  
有效范围：最小值为 1。最大值为 50。

 ** [nameContains](#API_GetSlotTypes_RequestSyntax) **   <a name="lex-GetSlotTypes-request-uri-nameContains"></a>
要在插槽类型名称中匹配的子字符串。如果插槽类型名称的任何部分与子字符串匹配，则将返回该插槽类型。例如，“xyz”同时匹配“xyzabc”和“abcxyz”。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`

 ** [nextToken](#API_GetSlotTypes_RequestSyntax) **   <a name="lex-GetSlotTypes-request-uri-nextToken"></a>
用于获取下一页插槽类型的分页令牌。如果对此 API 调用的响应被截断，Amazon Lex 将在响应中返回分页令牌。要获取下一页插槽类型，请在下一个请求中指定分页令牌。

## 请求正文
<a name="API_GetSlotTypes_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetSlotTypes_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "nextToken": "string",
   "slotTypes": [ 
      { 
         "createdDate": number,
         "description": "string",
         "lastUpdatedDate": number,
         "name": "string",
         "version": "string"
      }
   ]
}
```

## 响应元素
<a name="API_GetSlotTypes_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [nextToken](#API_GetSlotTypes_ResponseSyntax) **   <a name="lex-GetSlotTypes-response-nextToken"></a>
如果响应被截断，它会包含一个分页令牌，您可以在下次请求中指定该令牌来获取下一页插槽类型。  
类型：字符串

 ** [slotTypes](#API_GetSlotTypes_ResponseSyntax) **   <a name="lex-GetSlotTypes-response-slotTypes"></a>
对象数组，每种插槽类型对应一个对象，它提供诸如插槽类型的名称、版本和描述之类的信息。  
类型：[SlotTypeMetadata](API_SlotTypeMetadata.md) 对象数组

## 错误
<a name="API_GetSlotTypes_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_GetSlotTypes_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetSlotTypes) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetSlotTypes) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetSlotTypes) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetSlotTypes) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetSlotTypes) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetSlotTypes) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetSlotTypes) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetSlotTypes) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetSlotTypes) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetSlotTypes) 

# GetSlotTypeVersions
<a name="API_GetSlotTypeVersions"></a>

获取有关插槽类型的所有版本的信息。

`GetSlotTypeVersions` 操作会为每个版本的插槽类型返回一个 `SlotTypeMetadata` 对象。例如，如果插槽类型有三个带编号的版本，则 `GetSlotTypeVersions` 操作会在响应中返回四个 `SlotTypeMetadata` 对象，每个编号版本一个，`$LATEST` 版本一个。

`GetSlotTypeVersions` 操作始终返回至少一个版本，即 `$LATEST` 版本。

此操作需要 `lex:GetSlotTypeVersions` 操作的权限。

## 请求语法
<a name="API_GetSlotTypeVersions_RequestSyntax"></a>

```
GET /slottypes/name/versions/?maxResults=maxResults&nextToken=nextToken HTTP/1.1
```

## URI 请求参数
<a name="API_GetSlotTypeVersions_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [maxResults](#API_GetSlotTypeVersions_RequestSyntax) **   <a name="lex-GetSlotTypeVersions-request-uri-maxResults"></a>
要在响应中返回的插槽类型版本的最大数量。默认值为 10。  
有效范围：最小值为 1。最大值为 50。

 ** [name](#API_GetSlotTypeVersions_RequestSyntax) **   <a name="lex-GetSlotTypeVersions-request-uri-name"></a>
应返回其版本的插槽类型的名称。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [nextToken](#API_GetSlotTypeVersions_RequestSyntax) **   <a name="lex-GetSlotTypeVersions-request-uri-nextToken"></a>
用于获取下一页插槽类型版本的分页令牌。如果对此调用的响应被截断，Amazon Lex 将在响应中返回分页令牌。要获取下一页版本，请在下一个请求中指定分页令牌。

## 请求正文
<a name="API_GetSlotTypeVersions_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetSlotTypeVersions_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "nextToken": "string",
   "slotTypes": [ 
      { 
         "createdDate": number,
         "description": "string",
         "lastUpdatedDate": number,
         "name": "string",
         "version": "string"
      }
   ]
}
```

## 响应元素
<a name="API_GetSlotTypeVersions_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [nextToken](#API_GetSlotTypeVersions_ResponseSyntax) **   <a name="lex-GetSlotTypeVersions-response-nextToken"></a>
用于获取下一页插槽类型版本的分页令牌。如果对此调用的响应被截断，Amazon Lex 将在响应中返回分页令牌。要获取下一页版本，请在下一个请求中指定分页令牌。  
类型：字符串

 ** [slotTypes](#API_GetSlotTypeVersions_ResponseSyntax) **   <a name="lex-GetSlotTypeVersions-response-slotTypes"></a>
`SlotTypeMetadata` 对象数组，每个编号的插槽类型版本各一个，`$LATEST` 版本一个。  
类型：[SlotTypeMetadata](API_SlotTypeMetadata.md) 对象数组

## 错误
<a name="API_GetSlotTypeVersions_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_GetSlotTypeVersions_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetSlotTypeVersions) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetSlotTypeVersions) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetSlotTypeVersions) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetSlotTypeVersions) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetSlotTypeVersions) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetSlotTypeVersions) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetSlotTypeVersions) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetSlotTypeVersions) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetSlotTypeVersions) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetSlotTypeVersions) 

# GetUtterancesView
<a name="API_GetUtterancesView"></a>

使用 `GetUtterancesView` 操作来获取有关您的用户对您的机器人所说言语的信息。您可以使用这个列表来调整您的机器人响应的言语。

例如，假设您创建了一个机器人来订花。在您的用户使用您的机器人一段时间后，使用 `GetUtterancesView` 操作查看他们发出的请求以及请求是否成功。您可能会发现“我想要花”这句话没有被识别。您可以将这个言语添加到 `OrderFlowers` 意图中，这样您的机器人就能识别出这个言语。

发布新版本的机器人后，您可以获取有关旧版本和新版本的信息，以便比较两个版本的性能。

表达统计数据每天生成一次。可查询过去 15 天的数据。在每次请求中，您最多可以请求 5 个版本的机器人的信息。Amazon Lex 会返回该机器人在过去 15 天内收到的最频繁的言语。响应包含有关每个版本最多 100 句言语的信息。

在以下条件下，系统不会生成言语统计数据：
+ 创建机器人时，`childDirected` 字段设置为 True。
+ 您正在对一个或多个插槽使用插槽混淆处理。
+ 您已选择退出 Amazon Lex 改进计划。

此操作需要 `lex:GetUtterancesView` 操作的权限。

## 请求语法
<a name="API_GetUtterancesView_RequestSyntax"></a>

```
GET /bots/botname/utterances?view=aggregation&bot_versions=botVersions&status_type=statusType HTTP/1.1
```

## URI 请求参数
<a name="API_GetUtterancesView_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [botname](#API_GetUtterancesView_RequestSyntax) **   <a name="lex-GetUtterancesView-request-uri-botName"></a>
应返回其言语信息的机器人的名称。  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [botVersions](#API_GetUtterancesView_RequestSyntax) **   <a name="lex-GetUtterancesView-request-uri-botVersions"></a>
应返回其言语信息的机器人版本的数组。每个请求的限制为 5 个版本。  
数组成员：最少 1 个物品。最多 5 项。  
长度限制：最小长度为 1。长度上限为 64。  
模式：`\$LATEST|[0-9]+`  
是否必需：是

 ** [statusType](#API_GetUtterancesView_RequestSyntax) **   <a name="lex-GetUtterancesView-request-uri-statusType"></a>
要返回已识别且已处理的言语，请使用 `Detected`。要返回未识别的言语，请使用 `Missed`。  
有效值：`Detected | Missed`  
是否必需：是

## 请求体
<a name="API_GetUtterancesView_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_GetUtterancesView_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "botName": "string",
   "utterances": [ 
      { 
         "botVersion": "string",
         "utterances": [ 
            { 
               "count": number,
               "distinctUsers": number,
               "firstUtteredDate": number,
               "lastUtteredDate": number,
               "utteranceString": "string"
            }
         ]
      }
   ]
}
```

## 响应元素
<a name="API_GetUtterancesView_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [botName](#API_GetUtterancesView_ResponseSyntax) **   <a name="lex-GetUtterancesView-response-botName"></a>
要返回其言语信息的机器人的名称。  
类型：字符串  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`

 ** [utterances](#API_GetUtterancesView_ResponseSyntax) **   <a name="lex-GetUtterancesView-response-utterances"></a>
[UtteranceList](API_UtteranceList.md) 对象数组，每个对象都包含描述机器人已处理的言语的 [UtteranceData](API_UtteranceData.md) 对象列表。每个版本的响应最多包含 100 个 `UtteranceData` 对象。Amazon Lex 会返回该机器人在过去 15 天内收到的最频繁的言语。  
类型：[UtteranceList](API_UtteranceList.md) 对象数组

## 错误
<a name="API_GetUtterancesView_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

## 另请参阅
<a name="API_GetUtterancesView_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetUtterancesView) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/GetUtterancesView) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/GetUtterancesView) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetUtterancesView) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetUtterancesView) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/GetUtterancesView) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/GetUtterancesView) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetUtterancesView) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/GetUtterancesView) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/GetUtterancesView) 

# ListTagsForResource
<a name="API_ListTagsForResource"></a>

获取与指定资源关联的标签。只有机器人、机器人别名和机器人通道可以关联标签。

## 请求语法
<a name="API_ListTagsForResource_RequestSyntax"></a>

```
GET /tags/resourceArn HTTP/1.1
```

## URI 请求参数
<a name="API_ListTagsForResource_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [resourceArn](#API_ListTagsForResource_RequestSyntax) **   <a name="lex-ListTagsForResource-request-uri-resourceArn"></a>
要获得其标签列表的资源的 Amazon 资源名称 (ARN)。  
长度限制：最小长度为 1。最大长度为 1011。  
是否必需：是

## 请求体
<a name="API_ListTagsForResource_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_ListTagsForResource_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "tags": [ 
      { 
         "key": "string",
         "value": "string"
      }
   ]
}
```

## 响应元素
<a name="API_ListTagsForResource_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [tags](#API_ListTagsForResource_ResponseSyntax) **   <a name="lex-ListTagsForResource-response-tags"></a>
与资源关联的标签。  
类型：[Tag](API_Tag.md) 对象数组  
数组成员：最少 0 个物品。最多 200 项。

## 错误
<a name="API_ListTagsForResource_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_ListTagsForResource_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/ListTagsForResource) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/ListTagsForResource) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/ListTagsForResource) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/ListTagsForResource) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/ListTagsForResource) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/ListTagsForResource) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/ListTagsForResource) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/ListTagsForResource) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/ListTagsForResource) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/ListTagsForResource) 

# PutBot
<a name="API_PutBot"></a>

创建 Amazon Lex 对话机器人或替换现有机器人。创建或更新机器人时，您只需要指定名称、区域以及机器人是否针对未满 13 岁的儿童即可。您可以使用它在稍后添加意图，或者从现有机器人中移除意图。当您使用最少的信息创建机器人时，会创建或更新该机器人，但是 Amazon Lex 会返回 `` 响应 `FAILED`。您可以在添加一个或多个意图后构建机器人。有关 Amazon Lex 的更多信息，请参阅[Amazon Lex：工作原理](how-it-works.md)。

如果您指定现有机器人的名称，则请求中的字段将替换机器人 `$LATEST` 版本中的现有值。Amazon Lex 会删除您未在请求中提供值的所有字段，但 `idleTTLInSeconds` 和 `privacySettings` 字段除外，会将它们设置为默认值。如果您没有为必填字段指定值，Amazon Lex 会引发异常。

此操作需要 `lex:PutBot` 操作的权限。有关更多信息，请参阅 [适用于 Amazon Lex 的 Identity and Access Management](security-iam.md)。

## 请求语法
<a name="API_PutBot_RequestSyntax"></a>

```
PUT /bots/name/versions/$LATEST HTTP/1.1
Content-type: application/json

{
   "abortStatement": { 
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "checksum": "string",
   "childDirected": boolean,
   "clarificationPrompt": { 
      "maxAttempts": number,
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "createVersion": boolean,
   "description": "string",
   "detectSentiment": boolean,
   "enableModelImprovements": boolean,
   "idleSessionTTLInSeconds": number,
   "intents": [ 
      { 
         "intentName": "string",
         "intentVersion": "string"
      }
   ],
   "locale": "string",
   "nluIntentConfidenceThreshold": number,
   "processBehavior": "string",
   "tags": [ 
      { 
         "key": "string",
         "value": "string"
      }
   ],
   "voiceId": "string"
}
```

## URI 请求参数
<a name="API_PutBot_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [name](#API_PutBot_RequestSyntax) **   <a name="lex-PutBot-request-uri-name"></a>
机器人的名称。名称*不*区分大小写。  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`  
必需：是

## 请求体
<a name="API_PutBot_RequestBody"></a>

请求接受采用 JSON 格式的以下数据。

 ** [abortStatement](#API_PutBot_RequestSyntax) **   <a name="lex-PutBot-request-abortStatement"></a>
当 Amazon Lex 无法理解用户在上下文中的输入时，它会尝试几次引发信息。之后，Amazon Lex 将在 `abortStatement` 中定义的消息发送给用户，然后取消对话。要设置重试次数，请使用插槽类型的 `valueElicitationPrompt` 字段。  
例如，在订购披萨机器人中，Amazon Lex 可能会问用户“您想要什么类型的饼皮？” 如果用户的响应不是预期的响应之一（例如，“薄皮”、“深盘”等），Amazon Lex 会尝试几次引发正确的响应。  
例如，在订购披萨应用程序中，`OrderPizza` 可能是意图之一。此意图可能需要 `CrustType` 插槽。您可以在创建 `CrustType` 插槽时指定 `valueElicitationPrompt` 字段。  
如果您定义了回退意图，则不会向用户发送取消语句，而是使用回退意图。有关更多信息，请参阅[亚马逊。 FallbackIntent](https://docs.aws.amazon.com/lex/latest/dg/built-in-intent-fallback.html)。  
类型：[Statement](API_Statement.md) 对象  
必需：否

 ** [checksum](#API_PutBot_RequestSyntax) **   <a name="lex-PutBot-request-checksum"></a>
标识 `$LATEST` 版本的特定修订版。  
创建新机器人时，请将 `checksum` 字段留空。如果指定校验和，则会出现 `BadRequestException` 异常。  
当您想更新机器人时，请将 `checksum` 字段设置为 `$LATEST` 版本最新修订版的校验和。如果您未指定 ` checksum` 字段，或者校验和与 `$LATEST` 版本不匹配，则会出现 `PreconditionFailedException` 异常。  
类型：字符串  
必需：否

 ** [childDirected](#API_PutBot_RequestSyntax) **   <a name="lex-PutBot-request-childDirected"></a>
对于使用 Amazon Lex 模型构建服务创建的每个 Amazon Lex 机器人，您都必须通过在 `childDirected` 字段中指定 `true` 或 `false`，指定您对 Amazon Lex 的使用是否与全部或部分针对 13 岁以下儿童且受《儿童在线隐私保护法》(COPPA) 约束的网站、程序或其他应用程序有关。在 `childDirected` 字段中指定 `true`，即表示您确认您对 Amazon Lex 的使用**确实**与全部或部分针对 13 岁以下儿童且受 COPPA 约束的网站、计划或其他应用程序有关。在 `childDirected` 字段中指定 `false`，即表示您确认您对 Amazon Lex 的使用**不**与全部或部分针对 13 岁以下儿童且受 COPPA 约束的网站、计划或其他应用程序有关。如果在 `childDirected` 字段中指定默认值不能正确反映您确认您对 Amazon Lex 的使用不与全部或部分针对 13 岁以下儿童且受 COPPA 约束的网站、计划或其他应用程序有关，则您可以不指定。  
如果您对 Amazon Lex 的使用涉及全部或部分针对 13 岁以下儿童的网站、程序或其他应用程序，则必须获得 COPPA 规定的任何必需的可核实的家长同意。有关将 Amazon Lex 用于全部或部分针对 13 岁以下儿童的网站、程序或其他应用程序的信息，请参阅 [Amazon Lex 常见问题解答](https://aws.amazon.com/lex/faqs#data-security)。  
类型：布尔值  
是否必需：是

 ** [clarificationPrompt](#API_PutBot_RequestSyntax) **   <a name="lex-PutBot-request-clarificationPrompt"></a>
当 Amazon Lex 不了解用户的意图时，它会使用此消息进行澄清。要指定 Amazon Lex 应重复多少次澄清提示，请使用 `maxAttempts` 字段。如果 Amazon Lex 仍然无法理解，它会发送 `abortStatement` 字段中的消息。  
当您创建澄清提示时，请确保它建议用户做出正确的响应。例如，对于订购披萨和饮品的机器人，您可以创建这样的澄清提示：“您想做什么？ 您可以说“订一杯饮品”或“订一个披萨”。  
如果您定义了回退意图，则如果重复澄清提示的次数达到 `maxAttempts` 字段中定义的次数，则会调用该意图。有关更多信息，请参阅[亚马逊。 FallbackIntent](https://docs.aws.amazon.com/lex/latest/dg/built-in-intent-fallback.html)。  
如果您未定义澄清提示，则在运行时，Amazon Lex 将在三种情况下返回“400 错误请求”异常：  
+ 后续提示 — 当用户响应后续提示但不提供意图时。例如，在响应“您今天还想要其他东西吗？”后续提示时，用户回答“是”。由于 Amazon Lex 没有发送给用户以获取用户意图的澄清提示，因此它会返回“400 错误请求”异常。
+ Lambda 函数 — 使用 Lambda 函数时，您将返回 `ElicitIntent` 对话类型。由于 Amazon Lex 没有用于获取用户意图的澄清提示，因此它会返回“400 错误请求”异常。
+ PutSession 操作-使用`PutSession`操作时，您可以发送`ElicitIntent`对话类型。由于 Amazon Lex 没有用于获取用户意图的澄清提示，因此它会返回“400 错误请求”异常。
类型：[Prompt](API_Prompt.md) 对象  
必需：否

 ** [createVersion](#API_PutBot_RequestSyntax) **   <a name="lex-PutBot-request-createVersion"></a>
当设置为 `true` 时，将创建机器人的新编号版本。这与调用 `CreateBotVersion` 操作相同。如果不指定 `createVersion`，则默认值为 `false`。  
类型：布尔值  
必需：否

 ** [description](#API_PutBot_RequestSyntax) **   <a name="lex-PutBot-request-description"></a>
机器人的描述。  
类型：字符串  
长度限制：最小长度为 0。最大长度为 200。  
必需：否

 ** [detectSentiment](#API_PutBot_RequestSyntax) **   <a name="lex-PutBot-request-detectSentiment"></a>
当设置为 `true` 时，会将用户言语发送到 Amazon Comprehend 进行情绪分析。如果不指定 `detectSentiment`，则默认值为 `false`。  
类型：布尔值  
必需：否

 ** [enableModelImprovements](#API_PutBot_RequestSyntax) **   <a name="lex-PutBot-request-enableModelImprovements"></a>
设置为 `true` 以允许访问自然语言理解方面的改进。  
当将 `enableModelImprovements` 参数设置为 `true` 时，可以使用 `nluIntentConfidenceThreshold` 参数配置置信度分数。有关更多信息，请参阅[置信度分数](https://docs.aws.amazon.com/lex/latest/dg/confidence-scores.html)。  
您只能在某些区域中设置 `enableModelImprovements` 参数。如果将该参数设置为 `true`，则您的机器人可以获得准确性改进。  
您可以针对 en-US 区域设置将 `enableModelImprovements` 参数设置为 `false` 的区域有：  
+ 美国东部（弗吉尼亚州北部）(us-east-1)
+ 美国西部（俄勒冈州）(us-west-2)
+ 亚太地区（悉尼）(ap-southeast-2)
+ 欧洲（爱尔兰）(eu-west-1)
在其他区域和区域设置中，`enableModelImprovements` 参数默认设置为 `true`。在这些区域和区域设置中，将参数设置为 `false` 会引发 `ValidationException` 异常。  
类型：布尔值  
必需：否

 ** [idleSessionTTLInSeconds](#API_PutBot_RequestSyntax) **   <a name="lex-PutBot-request-idleSessionTTLInSeconds"></a>
Amazon Lex 保留对话中收集的数据的最长时间（秒）。  
用户交互会话在指定的时间内保持活动状态。如果在此期间未发生任何对话，则会话将过期并且 Amazon Lex 会删除在超时之前提供的所有数据。  
例如，假设用户选择了 OrderPizza 意图，但在下单的中途被偏离了方向。如果用户未在指定时间内完成订单，Amazon Lex 会丢弃其收集的插槽信息，用户必须重新开始。  
如果您未在 `PutBot` 操作请求中包含 `idleSessionTTLInSeconds` 元素，Amazon Lex 将使用默认值。如果请求替换现有的机器人，也是如此。  
默认值为 300 秒（5 分钟）。  
类型：整数  
有效范围：最小值为 60。最大值为 86400。  
必需：否

 ** [intents](#API_PutBot_RequestSyntax) **   <a name="lex-PutBot-request-intents"></a>
`Intent` 数据元数组。每个意图都代表一个用户可以表达的命令。例如，披萨订购机器人可能支持某种 OrderPizza 意图。有关更多信息，请参阅 [Amazon Lex：工作原理](how-it-works.md)。  
类型：[Intent](API_Intent.md) 对象数组  
必需：否

 ** [locale](#API_PutBot_RequestSyntax) **   <a name="lex-PutBot-request-locale"></a>
 指定机器人的目标区域设置。机器人中使用的任何意图都必须与机器人的区域设置兼容。  
默认值为 `en-US`。  
类型：字符串  
有效值：`de-DE | en-AU | en-GB | en-IN | en-US | es-419 | es-ES | es-US | fr-FR | fr-CA | it-IT | ja-JP | ko-KR`  
是否必需：是

 ** [nluIntentConfidenceThreshold](#API_PutBot_RequestSyntax) **   <a name="lex-PutBot-request-nluIntentConfidenceThreshold"></a>
确定在或[PostText](https://docs.aws.amazon.com/lex/latest/dg/API_runtime_PostText.html)响应中返回替代意图时 `AMAZON.FallbackIntent``AMAZON.KendraSearchIntent`，Amazon Lex 将在何处插入、[PostContent](https://docs.aws.amazon.com/lex/latest/dg/API_runtime_PostContent.html)或两者的阈值。 `AMAZON.FallbackIntent``AMAZON.KendraSearchIntent`并且只有在为机器人配置时才会被插入。  
必须将 `enableModelImprovements` 参数设置为 `true`，才能在以下区域中使用置信度分数。  
+ 美国东部（弗吉尼亚州北部）(us-east-1)
+ 美国西部（俄勒冈州）(us-west-2)
+ 亚太地区（悉尼）(ap-southeast-2)
+ 欧洲（爱尔兰）(eu-west-1)
在其他区域中，`enableModelImprovements` 参数默认设置为 `true`。  
例如，假设为机器人配置的置信度阈值为 0.80 和 `AMAZON.FallbackIntent`。Amazon Lex 返回了三个替代意图，置信度分数如下：IntentA (0.70)、IntentB (0.60) 和 IntentC (0.50)。来自 `PostText` 操作的响应将是：  
+ 亚马逊。 FallbackIntent
+ IntentA
+ IntentB
+ IntentC
类型：双精度  
有效范围：最小值为 0。最大值为 1。  
必需：否

 ** [processBehavior](#API_PutBot_RequestSyntax) **   <a name="lex-PutBot-request-processBehavior"></a>
如果您将 `processBehavior` 元素设置为 `BUILD`，Amazon Lex 会构建机器人以便它可以运行。如果您将该元素设置为 `SAVE`，Amazon Lex 会保存机器人，但不会构建它。  
如果您不指定此值，则默认值为 `BUILD`。  
类型：字符串  
有效值：`SAVE | BUILD`  
必需：否

 ** [tags](#API_PutBot_RequestSyntax) **   <a name="lex-PutBot-request-tags"></a>
要添加到自动程序的标签列表。您只能在创建机器人时添加标签，不能使用 `PutBot` 操作来更新机器人上的标签。要更新标签，请使用 `TagResource` 操作。  
类型：[Tag](API_Tag.md) 对象数组  
数组成员：最少 0 个物品。最多 200 项。  
必需：否

 ** [voiceId](#API_PutBot_RequestSyntax) **   <a name="lex-PutBot-request-voiceId"></a>
您希望 Amazon Lex 用于与用户进行语音交互的 Amazon Polly 语音 ID。为语音配置的区域设置必须与机器人的区域设置相匹配。有关更多信息，请参阅**《Amazon Polly 开发人员指南》中的 [Amazon Polly 中的语音](https://docs.aws.amazon.com/polly/latest/dg/voicelist.html)。  
类型：字符串  
必需：否

## 响应语法
<a name="API_PutBot_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "abortStatement": { 
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "checksum": "string",
   "childDirected": boolean,
   "clarificationPrompt": { 
      "maxAttempts": number,
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "createdDate": number,
   "createVersion": boolean,
   "description": "string",
   "detectSentiment": boolean,
   "enableModelImprovements": boolean,
   "failureReason": "string",
   "idleSessionTTLInSeconds": number,
   "intents": [ 
      { 
         "intentName": "string",
         "intentVersion": "string"
      }
   ],
   "lastUpdatedDate": number,
   "locale": "string",
   "name": "string",
   "nluIntentConfidenceThreshold": number,
   "status": "string",
   "tags": [ 
      { 
         "key": "string",
         "value": "string"
      }
   ],
   "version": "string",
   "voiceId": "string"
}
```

## 响应元素
<a name="API_PutBot_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [abortStatement](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-abortStatement"></a>
Amazon Lex 用来取消对话的消息。有关更多信息，请参阅 [PutBot](#API_PutBot)。  
类型：[Statement](API_Statement.md) 对象

 ** [checksum](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-checksum"></a>
您创建的机器人的校验和。  
类型：字符串

 ** [childDirected](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-childDirected"></a>
对于使用 Amazon Lex 模型构建服务创建的每个 Amazon Lex 机器人，您都必须通过在 `childDirected` 字段中指定 `true` 或 `false`，指定您对 Amazon Lex 的使用是否与全部或部分针对 13 岁以下儿童且受《儿童在线隐私保护法》(COPPA) 约束的网站、程序或其他应用程序有关。在 `childDirected` 字段中指定 `true`，即表示您确认您对 Amazon Lex 的使用**确实**与全部或部分针对 13 岁以下儿童且受 COPPA 约束的网站、计划或其他应用程序有关。在 `childDirected` 字段中指定 `false`，即表示您确认您对 Amazon Lex 的使用**不**与全部或部分针对 13 岁以下儿童且受 COPPA 约束的网站、计划或其他应用程序有关。如果在 `childDirected` 字段中指定默认值不能正确反映您确认您对 Amazon Lex 的使用不与全部或部分针对 13 岁以下儿童且受 COPPA 约束的网站、计划或其他应用程序有关，则您可以不指定。  
如果您对 Amazon Lex 的使用涉及全部或部分针对 13 岁以下儿童的网站、程序或其他应用程序，则必须获得 COPPA 规定的任何必需的可核实的家长同意。有关将 Amazon Lex 用于全部或部分针对 13 岁以下儿童的网站、程序或其他应用程序的信息，请参阅 [Amazon Lex 常见问题解答](https://aws.amazon.com/lex/faqs#data-security)。  
类型：布尔值

 ** [clarificationPrompt](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-clarificationPrompt"></a>
 Amazon Lex 在无法理解用户的请求时使用的提示。有关更多信息，请参阅 [PutBot](#API_PutBot)。  
类型：[Prompt](API_Prompt.md) 对象

 ** [createdDate](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-createdDate"></a>
机器人的创建日期。  
类型：时间戳

 ** [createVersion](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-createVersion"></a>
 `True`（如果创建了新版本的机器人）。如果请求中未指定 `createVersion` 字段，则在响应中将 `createVersion` 字段设置为 false。  
类型：布尔值

 ** [description](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-description"></a>
机器人的描述。  
类型：字符串  
长度限制：最小长度为 0。最大长度为 200。

 ** [detectSentiment](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-detectSentiment"></a>
 `true`（如果将机器人配置为将用户言语发送到 Amazon Comprehend 进行情绪分析）。如果请求中未指定 `detectSentiment` 字段，则响应中的 `detectSentiment` 字段为 `false`。  
类型：布尔值

 ** [enableModelImprovements](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-enableModelImprovements"></a>
表示机器人是否使用精度改进。`true` 表示机器人正在使用改进，否则为 `false`。  
类型：布尔值

 ** [failureReason](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-failureReason"></a>
如果 `status` 是 `FAILED`，则 Amazon Lex 会提供其未能构建机器人的原因。  
类型：字符串

 ** [idleSessionTTLInSeconds](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-idleSessionTTLInSeconds"></a>
Amazon Lex 保留对话中收集的数据的最长时间。有关更多信息，请参阅 [PutBot](#API_PutBot)。  
类型：整数  
有效范围：最小值为 60。最大值为 86400。

 ** [intents](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-intents"></a>
`Intent` 数据元数组。有关更多信息，请参阅 [PutBot](#API_PutBot)。  
类型：[Intent](API_Intent.md) 对象数组

 ** [lastUpdatedDate](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-lastUpdatedDate"></a>
机器人的更新日期。创建资源时，创建日期和上次更新日期相同。  
类型：时间戳

 ** [locale](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-locale"></a>
 机器人的目标区域设置。  
类型：字符串  
有效值：`de-DE | en-AU | en-GB | en-IN | en-US | es-419 | es-ES | es-US | fr-FR | fr-CA | it-IT | ja-JP | ko-KR`

 ** [name](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-name"></a>
机器人的名称。  
类型：字符串  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`

 ** [nluIntentConfidenceThreshold](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-nluIntentConfidenceThreshold"></a>
该分数决定 Amazon Lex 在或[PostText](https://docs.aws.amazon.com/lex/latest/dg/API_runtime_PostText.html)响应中返回替代意图时在何处插入`AMAZON.KendraSearchIntent`、[PostContent](https://docs.aws.amazon.com/lex/latest/dg/API_runtime_PostContent.html)或两者。`AMAZON.FallbackIntent` `AMAZON.FallbackIntent`如果实际可信度分数低于此值，则会插入。 `AMAZON.KendraSearchIntent`只有在为机器人配置时才会插入。  
类型：双精度  
有效范围：最小值为 0。最大值为 1。

 ** [status](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-status"></a>
 当您发送创建 `processBehavior` 设置为 `BUILD` 的机器人的请求时，Amazon Lex 会将 `status` 响应元素设置为 `BUILDING`。  
在 `READY_BASIC_TESTING` 状态下，您可以使用用户输入来测试机器人，这些输入与为机器人意图和插槽类型中的值配置的言语完全匹配。  
如果 Amazon Lex 无法构建机器人，则 Amazon Lex 会将 `status` 设置为 `FAILED`。Amazon Lex 会在 `failureReason` 响应元素中返回失败的原因。  
当将 `processBehavior` 设置为 `SAVE` 时，Amazon Lex 会将状态代码设置为 `NOT BUILT`。  
当机器人处于 `READY` 状态时，您可以测试和发布该机器人。  
类型：字符串  
有效值：`BUILDING | READY | READY_BASIC_TESTING | FAILED | NOT_BUILT`

 ** [tags](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-tags"></a>
与机器人关联的标签的列表。  
类型：[Tag](API_Tag.md) 对象数组  
数组成员：最少 0 个物品。最多 200 项。

 ** [version](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-version"></a>
自动程序的版本。对于新机器人，版本始终是 `$LATEST`。  
类型：字符串  
长度限制：最小长度为 1。长度上限为 64。  
模式：`\$LATEST|[0-9]+`

 ** [voiceId](#API_PutBot_ResponseSyntax) **   <a name="lex-PutBot-response-voiceId"></a>
Amazon Lex 用于和用户进行语音交互的 Amazon Polly 语音 ID。有关更多信息，请参阅 [PutBot](#API_PutBot)。  
类型：字符串

## 错误
<a name="API_PutBot_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** ConflictException **   
 处理请求时出现冲突。请再次尝试您的请求。  
HTTP 状态代码：409

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** PreconditionFailedException **   
 您尝试更改的资源的校验和与请求中的校验和不匹配。检查资源的校验和并重试。  
HTTP 状态代码：412

## 另请参阅
<a name="API_PutBot_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/PutBot) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/PutBot) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/PutBot) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/PutBot) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/PutBot) 
+  [AWS JavaScript V3 版软件开发工具包](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/PutBot) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/PutBot) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/PutBot) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/PutBot) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/PutBot) 

# PutBotAlias
<a name="API_PutBotAlias"></a>

为指定版本的机器人创建别名，或替换指定机器人的别名。要更改别名指向的机器人的版本，请替换别名。有关别名的更多信息，请参阅[版本控制和别名](versioning-aliases.md)。

此操作需要 `lex:PutBotAlias` 操作的权限。

## 请求语法
<a name="API_PutBotAlias_RequestSyntax"></a>

```
PUT /bots/botName/aliases/name HTTP/1.1
Content-type: application/json

{
   "botVersion": "string",
   "checksum": "string",
   "conversationLogs": { 
      "iamRoleArn": "string",
      "logSettings": [ 
         { 
            "destination": "string",
            "kmsKeyArn": "string",
            "logType": "string",
            "resourceArn": "string"
         }
      ]
   },
   "description": "string",
   "tags": [ 
      { 
         "key": "string",
         "value": "string"
      }
   ]
}
```

## URI 请求参数
<a name="API_PutBotAlias_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [botName](#API_PutBotAlias_RequestSyntax) **   <a name="lex-PutBotAlias-request-uri-botName"></a>
机器人的名称。  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [name](#API_PutBotAlias_RequestSyntax) **   <a name="lex-PutBotAlias-request-uri-name"></a>
别名的名称。名称*不*区分大小写。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
必需：是

## 请求体
<a name="API_PutBotAlias_RequestBody"></a>

请求接受采用 JSON 格式的以下数据。

 ** [botVersion](#API_PutBotAlias_RequestSyntax) **   <a name="lex-PutBotAlias-request-botVersion"></a>
自动程序的版本。  
类型：字符串  
长度限制：最小长度为 1。长度上限为 64。  
模式：`\$LATEST|[0-9]+`  
是否必需：是

 ** [checksum](#API_PutBotAlias_RequestSyntax) **   <a name="lex-PutBotAlias-request-checksum"></a>
标识 `$LATEST` 版本的特定修订版。  
创建新机器人别名时，请将 `checksum` 字段留空。如果指定校验和，则会出现 `BadRequestException` 异常。  
当您想更新机器人别名时，请将 `checksum` 字段设置为 `$LATEST` 版本最新修订版的校验和。如果您未指定 ` checksum` 字段，或者校验和与 `$LATEST` 版本不匹配，则会出现 `PreconditionFailedException` 异常。  
类型：字符串  
必需：否

 ** [conversationLogs](#API_PutBotAlias_RequestSyntax) **   <a name="lex-PutBotAlias-request-conversationLogs"></a>
别名的对话日志的设置。  
类型：[ConversationLogsRequest](API_ConversationLogsRequest.md) 对象  
必需：否

 ** [description](#API_PutBotAlias_RequestSyntax) **   <a name="lex-PutBotAlias-request-description"></a>
别名的描述。  
类型：字符串  
长度限制：最小长度为 0。最大长度为 200。  
必需：否

 ** [tags](#API_PutBotAlias_RequestSyntax) **   <a name="lex-PutBotAlias-request-tags"></a>
要添加到机器人的标签列表。您只能在创建别名时添加标签，不能使用 `PutBotAlias` 操作来更新机器人别名上的标签。要更新标签，请使用 `TagResource` 操作。  
类型：[Tag](API_Tag.md) 对象数组  
数组成员：最少 0 个物品。最多 200 项。  
必需：否

## 响应语法
<a name="API_PutBotAlias_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "botName": "string",
   "botVersion": "string",
   "checksum": "string",
   "conversationLogs": { 
      "iamRoleArn": "string",
      "logSettings": [ 
         { 
            "destination": "string",
            "kmsKeyArn": "string",
            "logType": "string",
            "resourceArn": "string",
            "resourcePrefix": "string"
         }
      ]
   },
   "createdDate": number,
   "description": "string",
   "lastUpdatedDate": number,
   "name": "string",
   "tags": [ 
      { 
         "key": "string",
         "value": "string"
      }
   ]
}
```

## 响应元素
<a name="API_PutBotAlias_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [botName](#API_PutBotAlias_ResponseSyntax) **   <a name="lex-PutBotAlias-response-botName"></a>
别名指向的自动程序的名称。  
类型：字符串  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`

 ** [botVersion](#API_PutBotAlias_ResponseSyntax) **   <a name="lex-PutBotAlias-response-botVersion"></a>
别名指向的机器人的版本。  
类型：字符串  
长度限制：最小长度为 1。长度上限为 64。  
模式：`\$LATEST|[0-9]+`

 ** [checksum](#API_PutBotAlias_ResponseSyntax) **   <a name="lex-PutBotAlias-response-checksum"></a>
别名的最新版本的校验和。  
类型：字符串

 ** [conversationLogs](#API_PutBotAlias_ResponseSyntax) **   <a name="lex-PutBotAlias-response-conversationLogs"></a>
确定 Amazon Lex 如何使用对话日志作为别名的设置。  
类型：[ConversationLogsResponse](API_ConversationLogsResponse.md) 对象

 ** [createdDate](#API_PutBotAlias_ResponseSyntax) **   <a name="lex-PutBotAlias-response-createdDate"></a>
机器人别名的创建日期。  
类型：时间戳

 ** [description](#API_PutBotAlias_ResponseSyntax) **   <a name="lex-PutBotAlias-response-description"></a>
别名的描述。  
类型：字符串  
长度限制：最小长度为 0。最大长度为 200。

 ** [lastUpdatedDate](#API_PutBotAlias_ResponseSyntax) **   <a name="lex-PutBotAlias-response-lastUpdatedDate"></a>
机器人别名的更新日期。创建资源时，创建日期和上次更新日期相同。  
类型：时间戳

 ** [name](#API_PutBotAlias_ResponseSyntax) **   <a name="lex-PutBotAlias-response-name"></a>
别名的名称。  
类型：字符串  
长度约束：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`

 ** [tags](#API_PutBotAlias_ResponseSyntax) **   <a name="lex-PutBotAlias-response-tags"></a>
与机器人关联的标签的列表。  
类型：[Tag](API_Tag.md) 对象数组  
数组成员：最少 0 个物品。最多 200 项。

## 错误
<a name="API_PutBotAlias_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** ConflictException **   
 处理请求时出现冲突。请再次尝试您的请求。  
HTTP 状态代码：409

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** PreconditionFailedException **   
 您尝试更改的资源的校验和与请求中的校验和不匹配。检查资源的校验和并重试。  
HTTP 状态代码：412

## 另请参阅
<a name="API_PutBotAlias_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/PutBotAlias) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/PutBotAlias) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/PutBotAlias) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/PutBotAlias) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/PutBotAlias) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/PutBotAlias) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/PutBotAlias) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/PutBotAlias) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/PutBotAlias) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/PutBotAlias) 

# PutIntent
<a name="API_PutIntent"></a>

创建目的或替换现有目的。

要定义用户和您的机器人之间的互动，您可以使用一个或多个意图。例如，对于订购披萨机器人，您可以创建一个 `OrderPizza` 意图。

要创建意图或替换现有意图，您必须提供以下信息：
+ 意图名称。例如 `OrderPizza`。
+ 示例言语。例如，“请问我可以点披萨吗。” 和“我想订一个披萨。”
+ 有待收集的信息。您可以为机器人向用户请求的信息指定插槽类型。您可以指定标准插槽类型（例如日期或时间），也可以指定自定义插槽类型（例如披萨的大小和外皮）。
+ 履行意图的方式。您可以提供 Lambda 函数或配置意图以将意图信息返回给客户端应用程序。如果您使用 Lambda 函数，则当所有意图信息都可用时，Amazon Lex 会调用您的 Lambda 函数。如果您将意图配置为仅将意图信息返回给客户端应用程序。

您可以在请求中指定其他可选信息，例如：
+ 要求用户确认意图的确认提示。例如，“我可以为您的披萨下订单了吗？”
+ 意图实现后要发送给用户的结论语句。例如，“我已经为您的披萨下订单了。”
+ 一个后续提示，询问用户是否要进行其他活动。例如，询问“您想和披萨一起订一杯饮品吗？”

如果您指定现有意图名称来更新意图，Amazon Lex 会将意图的 `$LATEST` 版本中的值替换为请求中的值。Amazon Lex 会删除您在请求中未提供的字段。如果您没有指定必填字段，Amazon Lex 会引发异常。更新意图的 `$LATEST` 版本时，任何使用意图的 `$LATEST` 版本的机器人的 `status` 字段都将设置为 `NOT_BUILT`。

有关更多信息，请参阅 [Amazon Lex：工作原理](how-it-works.md)。

此操作需要 `lex:PutIntent` 操作的权限。

## 请求语法
<a name="API_PutIntent_RequestSyntax"></a>

```
PUT /intents/name/versions/$LATEST HTTP/1.1
Content-type: application/json

{
   "checksum": "string",
   "conclusionStatement": { 
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "confirmationPrompt": { 
      "maxAttempts": number,
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "createVersion": boolean,
   "description": "string",
   "dialogCodeHook": { 
      "messageVersion": "string",
      "uri": "string"
   },
   "followUpPrompt": { 
      "prompt": { 
         "maxAttempts": number,
         "messages": [ 
            { 
               "content": "string",
               "contentType": "string",
               "groupNumber": number
            }
         ],
         "responseCard": "string"
      },
      "rejectionStatement": { 
         "messages": [ 
            { 
               "content": "string",
               "contentType": "string",
               "groupNumber": number
            }
         ],
         "responseCard": "string"
      }
   },
   "fulfillmentActivity": { 
      "codeHook": { 
         "messageVersion": "string",
         "uri": "string"
      },
      "type": "string"
   },
   "inputContexts": [ 
      { 
         "name": "string"
      }
   ],
   "kendraConfiguration": { 
      "kendraIndex": "string",
      "queryFilterString": "string",
      "role": "string"
   },
   "outputContexts": [ 
      { 
         "name": "string",
         "timeToLiveInSeconds": number,
         "turnsToLive": number
      }
   ],
   "parentIntentSignature": "string",
   "rejectionStatement": { 
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "sampleUtterances": [ "string" ],
   "slots": [ 
      { 
         "defaultValueSpec": { 
            "defaultValueList": [ 
               { 
                  "defaultValue": "string"
               }
            ]
         },
         "description": "string",
         "name": "string",
         "obfuscationSetting": "string",
         "priority": number,
         "responseCard": "string",
         "sampleUtterances": [ "string" ],
         "slotConstraint": "string",
         "slotType": "string",
         "slotTypeVersion": "string",
         "valueElicitationPrompt": { 
            "maxAttempts": number,
            "messages": [ 
               { 
                  "content": "string",
                  "contentType": "string",
                  "groupNumber": number
               }
            ],
            "responseCard": "string"
         }
      }
   ]
}
```

## URI 请求参数
<a name="API_PutIntent_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [name](#API_PutIntent_RequestSyntax) **   <a name="lex-PutIntent-request-uri-name"></a>
意图的名称。名称*不*区分大小写。  
该名称不能与内置意图名称匹配，否则含有“AMAZON.”的内置意图名称 会被删除。例如，由于存在名为 `AMAZON.HelpIntent` 的内置意图，因此您无法创建名为的 `HelpIntent` 的自定义意图。  
有关内置目的的列表，请参阅 [Alexa Skills Kit](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/built-in-intent-ref/standard-intents) 中的*标准内置目的*。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
必需：是

## 请求体
<a name="API_PutIntent_RequestBody"></a>

请求接受采用 JSON 格式的以下数据。

 ** [checksum](#API_PutIntent_RequestSyntax) **   <a name="lex-PutIntent-request-checksum"></a>
标识 `$LATEST` 版本的特定修订版。  
创建新意图时，请将 `checksum` 字段留空。如果指定校验和，则会出现 `BadRequestException` 异常。  
当您想更新意图时，请将 `checksum` 字段设置为 `$LATEST` 版本最新修订版的校验和。如果您未指定 ` checksum` 字段，或者校验和与 `$LATEST` 版本不匹配，则会出现 `PreconditionFailedException` 异常。  
类型：字符串  
必需：否

 ** [conclusionStatement](#API_PutIntent_RequestSyntax) **   <a name="lex-PutIntent-request-conclusionStatement"></a>
 您希望 Amazon Lex 在 Lambda 函数成功履行意图后向用户传达的语句。  
仅当您在 `fulfillmentActivity` 中提供 Lambda 函数时，此元素才有意义。如果您将意图返回给客户端应用程序，则无法指定此元素。  
`followUpPrompt` 和 `conclusionStatement` 是互斥的。您只能指定其中一个。
类型：[Statement](API_Statement.md) 对象  
必需：否

 ** [confirmationPrompt](#API_PutIntent_RequestSyntax) **   <a name="lex-PutIntent-request-confirmationPrompt"></a>
提示用户确认目的。此问题的回答应为 yes 或 no。  
Amazon Lex 使用此提示来确保用户确认意图可履行。例如，对于 `OrderPizza` 意图，您可能需要在下单之前确认订单是正确的。对于其他意图，例如仅回答用户问题的意图，在提供信息之前，您可能无需要求用户进行确认。  
您必须同时提供 `rejectionStatement` 和 `confirmationPrompt`，或者两者都不提供。
类型：[Prompt](API_Prompt.md) 对象  
必需：否

 ** [createVersion](#API_PutIntent_RequestSyntax) **   <a name="lex-PutIntent-request-createVersion"></a>
当设置为 `true` 时，将创建意图的新编号版本。这与调用 `CreateIntentVersion` 操作相同。如果不指定 `createVersion`，则默认值为 `false`。  
类型：布尔值  
必需：否

 ** [description](#API_PutIntent_RequestSyntax) **   <a name="lex-PutIntent-request-description"></a>
目的的描述。  
类型：字符串  
长度限制：最小长度为 0。最大长度为 200。  
必需：否

 ** [dialogCodeHook](#API_PutIntent_RequestSyntax) **   <a name="lex-PutIntent-request-dialogCodeHook"></a>
 指定为每个用户输入调用的 Lambda 函数。您可以调用此 Lambda 函数对用户交互进行个性化。  
例如，假设您的机器人确定用户是 John。您的 Lambda 函数可能会从后端数据库中检索 John 的信息并预先填充一些值。例如，如果您发现 John 对谷蛋白过敏，则可以将相应的意图插槽 `GlutenIntolerant` 设置为 true。您可能会找到 John 的电话号码并设置相应的会话属性。  
类型：[CodeHook](API_CodeHook.md) 对象  
必需：否

 ** [followUpPrompt](#API_PutIntent_RequestSyntax) **   <a name="lex-PutIntent-request-followUpPrompt"></a>
Amazon Lex 将在履行意图后使用此提示来征求其他活动。例如，在履行 `OrderPizza` 意图后，您可以提示用户订购饮品。  
Amazon Lex 采取的操作取决于用户的响应，如下所示：  
+ 如果用户说“是”，则会使用为机器人配置的澄清提示进行响应。
+ 如果用户说“是”，然后继续说一句触发意图的言语，则会启动针对该意图的对话。
+ 如果用户说“否”，则会使用为后续提示配置的拒绝语句进行响应。
+ 如果它无法识别出这句话，它会再次重复后续提示。
`followUpPrompt` 字段和 `conclusionStatement` 字段是互斥的。您只能指定其中一个。  
类型：[FollowUpPrompt](API_FollowUpPrompt.md) 对象  
必需：否

 ** [fulfillmentActivity](#API_PutIntent_RequestSyntax) **   <a name="lex-PutIntent-request-fulfillmentActivity"></a>
必需。描述履行意图的方式。例如，在用户提供披萨订单的所有信息后，`fulfillmentActivity` 定义机器人如何向当地披萨店下订单。  
 您可以将 Amazon Lex 配置为将所有意图信息返回给客户端应用程序，或者指示其调用可以处理意图的 Lambda 函数（例如，向披萨店下订单）。  
类型：[FulfillmentActivity](API_FulfillmentActivity.md) 对象  
必需：否

 ** [inputContexts](#API_PutIntent_RequestSyntax) **   <a name="lex-PutIntent-request-inputContexts"></a>
`InputContext` 对象数组，列出了 Amazon Lex 在与用户的对话中选择意图时必须处于活动状态的上下文。  
类型：[InputContext](API_InputContext.md) 对象数组  
数组成员：最少 0 个物品。最多 5 项。  
必需：否

 ** [kendraConfiguration](#API_PutIntent_RequestSyntax) **   <a name="lex-PutIntent-request-kendraConfiguration"></a>
使用 `AMAZON.KendraSearchIntent` 意图以连接至 Amazon Kendra 索引所需的配置信息。有关更多信息，请参阅[亚马逊。 KendraSearchIntent](https://docs.aws.amazon.com/lex/latest/dg/built-in-intent-kendra-search.html)。  
类型：[KendraConfiguration](API_KendraConfiguration.md) 对象  
必需：否

 ** [outputContexts](#API_PutIntent_RequestSyntax) **   <a name="lex-PutIntent-request-outputContexts"></a>
`OutputContext` 对象数组，列出了履行意图时意图激活的上下文。  
类型：[OutputContext](API_OutputContext.md) 对象数组  
数组成员：最少 0 个物品。最多 10 个物品。  
必需：否

 ** [parentIntentSignature](#API_PutIntent_RequestSyntax) **   <a name="lex-PutIntent-request-parentIntentSignature"></a>
内置目的的唯一标识符，此目的建立在它的基础之上。要查找意图的签名，请参阅 *Alexa Skills Kit* 中的[标准内置意图](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/built-in-intent-ref/standard-intents)。  
类型：字符串  
必需：否

 ** [rejectionStatement](#API_PutIntent_RequestSyntax) **   <a name="lex-PutIntent-request-rejectionStatement"></a>
当用户对 `confirmationPrompt` 中定义的问题回答“否”时，Amazon Lex 将使用此响应进行响应，以确认意图已被取消。  
您必须同时提供 `rejectionStatement` 和 `confirmationPrompt`，或者两者都不提供。
类型：[Statement](API_Statement.md) 对象  
必需：否

 ** [sampleUtterances](#API_PutIntent_RequestSyntax) **   <a name="lex-PutIntent-request-sampleUtterances"></a>
用户可能用以传递意图的一组言语（字符串）。例如，“我想要 \$1PizzaSize\$1 披萨”、“订购 \$1Quantity\$1 \$1PizzaSize\$1 个披萨”。  
在每句言语中，插槽名称都用大括号括起来。  
类型：字符串数组  
数组成员：最少 0 项。最多 1500 项。  
长度限制：最小长度为 1。最大长度为 200。  
必需：否

 ** [slots](#API_PutIntent_RequestSyntax) **   <a name="lex-PutIntent-request-slots"></a>
意图插槽数组。在运行时，Amazon Lex 使用插槽中定义的提示从用户那里引发所需的插槽值。有关更多信息，请参阅 [Amazon Lex：工作原理](how-it-works.md)。  
类型：[Slot](API_Slot.md) 对象数组  
数组成员：最少 0 个物品。最多 100 个项目。  
必需：否

## 响应语法
<a name="API_PutIntent_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "checksum": "string",
   "conclusionStatement": { 
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "confirmationPrompt": { 
      "maxAttempts": number,
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "createdDate": number,
   "createVersion": boolean,
   "description": "string",
   "dialogCodeHook": { 
      "messageVersion": "string",
      "uri": "string"
   },
   "followUpPrompt": { 
      "prompt": { 
         "maxAttempts": number,
         "messages": [ 
            { 
               "content": "string",
               "contentType": "string",
               "groupNumber": number
            }
         ],
         "responseCard": "string"
      },
      "rejectionStatement": { 
         "messages": [ 
            { 
               "content": "string",
               "contentType": "string",
               "groupNumber": number
            }
         ],
         "responseCard": "string"
      }
   },
   "fulfillmentActivity": { 
      "codeHook": { 
         "messageVersion": "string",
         "uri": "string"
      },
      "type": "string"
   },
   "inputContexts": [ 
      { 
         "name": "string"
      }
   ],
   "kendraConfiguration": { 
      "kendraIndex": "string",
      "queryFilterString": "string",
      "role": "string"
   },
   "lastUpdatedDate": number,
   "name": "string",
   "outputContexts": [ 
      { 
         "name": "string",
         "timeToLiveInSeconds": number,
         "turnsToLive": number
      }
   ],
   "parentIntentSignature": "string",
   "rejectionStatement": { 
      "messages": [ 
         { 
            "content": "string",
            "contentType": "string",
            "groupNumber": number
         }
      ],
      "responseCard": "string"
   },
   "sampleUtterances": [ "string" ],
   "slots": [ 
      { 
         "defaultValueSpec": { 
            "defaultValueList": [ 
               { 
                  "defaultValue": "string"
               }
            ]
         },
         "description": "string",
         "name": "string",
         "obfuscationSetting": "string",
         "priority": number,
         "responseCard": "string",
         "sampleUtterances": [ "string" ],
         "slotConstraint": "string",
         "slotType": "string",
         "slotTypeVersion": "string",
         "valueElicitationPrompt": { 
            "maxAttempts": number,
            "messages": [ 
               { 
                  "content": "string",
                  "contentType": "string",
                  "groupNumber": number
               }
            ],
            "responseCard": "string"
         }
      }
   ],
   "version": "string"
}
```

## 响应元素
<a name="API_PutIntent_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [checksum](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-checksum"></a>
创建或更新意图的 `$LATEST` 版本的校验和。  
类型：字符串

 ** [conclusionStatement](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-conclusionStatement"></a>
在 `fulfillmentActivity` 意图中指定的 Lambda 函数履行意图后，Amazon Lex 会将此语句传达给用户。  
类型：[Statement](API_Statement.md) 对象

 ** [confirmationPrompt](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-confirmationPrompt"></a>
如果在意图中已定义，则 Amazon Lex 会在履行意图之前提示用户确认意图。  
类型：[Prompt](API_Prompt.md) 对象

 ** [createdDate](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-createdDate"></a>
意图的创建日期。  
类型：时间戳

 ** [createVersion](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-createVersion"></a>
 `True`（如果创建了新版本的意图）。如果请求中未指定 `createVersion` 字段，则在响应中将 `createVersion` 字段设置为 false。  
类型：布尔值

 ** [description](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-description"></a>
目的的描述。  
类型：字符串  
长度限制：最小长度为 0。最大长度为 200。

 ** [dialogCodeHook](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-dialogCodeHook"></a>
如果在意图中已定义，Amazon Lex 会为每个用户输入调用 Lambda 函数。  
类型：[CodeHook](API_CodeHook.md) 对象

 ** [followUpPrompt](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-followUpPrompt"></a>
如果已在意图中定义，则 Amazon Lex 会在履行意图后使用此提示来征求其他用户活动。  
类型：[FollowUpPrompt](API_FollowUpPrompt.md) 对象

 ** [fulfillmentActivity](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-fulfillmentActivity"></a>
如果已在意图中定义，则在用户提供意图所需的所有信息后，Amazon Lex 会调用 Lambda 函数来履行意图。  
类型：[FulfillmentActivity](API_FulfillmentActivity.md) 对象

 ** [inputContexts](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-inputContexts"></a>
`InputContext` 对象数组，列出了 Amazon Lex 在与用户的对话中选择意图时必须处于活动状态的上下文。  
类型：[InputContext](API_InputContext.md) 对象数组  
数组成员：最少 0 个物品。最多 5 项。

 ** [kendraConfiguration](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-kendraConfiguration"></a>
连接至 Amazon Kendra 索引并使用 `AMAZON.KendraSearchIntent` 意图所需的配置信息（如果有）。  
类型：[KendraConfiguration](API_KendraConfiguration.md) 对象

 ** [lastUpdatedDate](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-lastUpdatedDate"></a>
意图的更新日期。创建资源时，创建日期和上次更新日期相同。  
类型：时间戳

 ** [name](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-name"></a>
意图的名称。  
类型：字符串  
长度约束：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`

 ** [outputContexts](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-outputContexts"></a>
`OutputContext` 对象数组，列出了履行意图时意图激活的上下文。  
类型：[OutputContext](API_OutputContext.md) 对象数组  
数组成员：最少 0 个物品。最多 10 个物品。

 ** [parentIntentSignature](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-parentIntentSignature"></a>
内置意图唯一标识符，此意图建立在该意图的基础之上。  
类型：字符串

 ** [rejectionStatement](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-rejectionStatement"></a>
当用户对 `confirmationPrompt` 中定义的问题回答“否”时，Amazon Lex 将使用此语句进行响应，以确认意图已被取消。  
类型：[Statement](API_Statement.md) 对象

 ** [sampleUtterances](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-sampleUtterances"></a>
 为意图配置的一组示例言语。  
类型：字符串数组  
数组成员：最少 0 项。最多 1500 项。  
长度限制：最小长度为 1。最大长度为 200。

 ** [slots](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-slots"></a>
为意图配置的一系列意图插槽。  
类型：[Slot](API_Slot.md) 对象数组  
数组成员：最少 0 个物品。最多 100 个项目。

 ** [version](#API_PutIntent_ResponseSyntax) **   <a name="lex-PutIntent-response-version"></a>
意图的版本。对于新意图，版本始终是 `$LATEST`。  
类型：字符串  
长度限制：最小长度为 1。长度上限为 64。  
模式：`\$LATEST|[0-9]+`

## 错误
<a name="API_PutIntent_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** ConflictException **   
 处理请求时出现冲突。请再次尝试您的请求。  
HTTP 状态代码：409

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** PreconditionFailedException **   
 您尝试更改的资源的校验和与请求中的校验和不匹配。检查资源的校验和并重试。  
HTTP 状态代码：412

## 另请参阅
<a name="API_PutIntent_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/PutIntent) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/PutIntent) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/PutIntent) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/PutIntent) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/PutIntent) 
+  [AWS JavaScript V3 版软件开发工具包](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/PutIntent) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/PutIntent) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/PutIntent) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/PutIntent) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/PutIntent) 

# PutSlotType
<a name="API_PutSlotType"></a>

创建自定义槽类型或替换现有自定义槽类型。

要创建自定义插槽类型，请为插槽类型指定名称和一组枚举值，这些值是此类插槽可以假设的值。有关更多信息，请参阅 [Amazon Lex：工作原理](how-it-works.md)。

如果您指定现有插槽类型的名称，则请求中的字段将替换该插槽类型 `$LATEST` 版本中的现有值。Amazon Lex 会删除您在请求中未提供的字段。如果您没有指定必填字段，Amazon Lex 会引发异常。更新插槽类型的 `$LATEST` 版本时，如果机器人使用包含该插槽类型的意图的 `$LATEST` 版本，则机器人的 `status` 字段将设置为 `NOT_BUILT`。

此操作需要 `lex:PutSlotType` 操作的权限。

## 请求语法
<a name="API_PutSlotType_RequestSyntax"></a>

```
PUT /slottypes/name/versions/$LATEST HTTP/1.1
Content-type: application/json

{
   "checksum": "string",
   "createVersion": boolean,
   "description": "string",
   "enumerationValues": [ 
      { 
         "synonyms": [ "string" ],
         "value": "string"
      }
   ],
   "parentSlotTypeSignature": "string",
   "slotTypeConfigurations": [ 
      { 
         "regexConfiguration": { 
            "pattern": "string"
         }
      }
   ],
   "valueSelectionStrategy": "string"
}
```

## URI 请求参数
<a name="API_PutSlotType_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [name](#API_PutSlotType_RequestSyntax) **   <a name="lex-PutSlotType-request-uri-name"></a>
槽类型的名称。名称*不*区分大小写。  
该名称不能与内置插槽类型名称匹配，否则带有“AMAZON”的内置插槽类型名称 会被删除。例如，由于有一个名为 `AMAZON.DATE` 的内置插槽类型，因此您无法创建名为 `DATE` 的自定义插槽类型。  
有关内置插槽类型的列表，请参阅 [Alexa Skills Kit](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/built-in-intent-ref/slot-type-reference) 中的*插槽类型参考*。  
长度限制：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`  
必需：是

## 请求体
<a name="API_PutSlotType_RequestBody"></a>

请求接受采用 JSON 格式的以下数据。

 ** [checksum](#API_PutSlotType_RequestSyntax) **   <a name="lex-PutSlotType-request-checksum"></a>
标识 `$LATEST` 版本的特定修订版。  
创建新的插槽类型时，请将 `checksum` 字段留空。如果指定校验和，则会出现 `BadRequestException` 异常。  
当您想更新插槽类型时，请将 `checksum` 字段设置为 `$LATEST` 版本最新修订版的校验和。如果您未指定 ` checksum` 字段，或者校验和与 `$LATEST` 版本不匹配，则会出现 `PreconditionFailedException` 异常。  
类型：字符串  
必需：否

 ** [createVersion](#API_PutSlotType_RequestSyntax) **   <a name="lex-PutSlotType-request-createVersion"></a>
当设置为 `true` 时，将创建插槽类型的新编号版本。这与调用 `CreateSlotTypeVersion` 操作相同。如果不指定 `createVersion`，则默认值为 `false`。  
类型：布尔值  
必需：否

 ** [description](#API_PutSlotType_RequestSyntax) **   <a name="lex-PutSlotType-request-description"></a>
槽类型的描述。  
类型：字符串  
长度限制：最小长度为 0。最大长度为 200。  
必需：否

 ** [enumerationValues](#API_PutSlotType_RequestSyntax) **   <a name="lex-PutSlotType-request-enumerationValues"></a>
定义插槽类型可采用值的 `EnumerationValue` 对象的列表。每个值可以有 `synonyms` 的列表，后者可帮助训练机器学习模型以便解析插槽值。  
正则表达式插槽类型不需要枚举值。所有其他插槽类型都需要枚举值列表。  
当 Amazon Lex 解析插槽值时，它会生成一个分辨率列表，其中包含该插槽最多五个可能的值。如果您使用 Lambda 函数，则此解析列表将传递给该函数。如果您未使用 Lambda 函数，可以选择返回用户输入的值或解析列表中的第一个值并作为插槽值。`valueSelectionStrategy` 字段表示要使用的选项。  
类型：[EnumerationValue](API_EnumerationValue.md) 对象数组  
数组成员：最少 0 个物品。最多 10000 项。  
必需：否

 ** [parentSlotTypeSignature](#API_PutSlotType_RequestSyntax) **   <a name="lex-PutSlotType-request-parentSlotTypeSignature"></a>
用作此插槽类型的父级的内置插槽类型。当您定义父级插槽类型时，新的插槽类型将具有父级插槽类型的所有相同配置。  
仅支持 `AMAZON.AlphaNumeric`。  
类型：字符串  
长度约束：最小长度为 1。最大长度为 100。  
模式：`^((AMAZON\.)_?|[A-Za-z]_?)+`  
必需：否

 ** [slotTypeConfigurations](#API_PutSlotType_RequestSyntax) **   <a name="lex-PutSlotType-request-slotTypeConfigurations"></a>
扩展父级内置插槽类型的配置信息。配置已添加到父插槽类型的设置中。  
类型：[SlotTypeConfiguration](API_SlotTypeConfiguration.md) 对象数组  
数组成员：最少 0 个物品。最多 10 个物品。  
必需：否

 ** [valueSelectionStrategy](#API_PutSlotType_RequestSyntax) **   <a name="lex-PutSlotType-request-valueSelectionStrategy"></a>
确定 Amazon Lex 用来返回插槽值类型的插槽解析策略。该字段可以为以下值之一：  
+  `ORIGINAL_VALUE` — 如果用户值与插槽值相近，返回由用户输入的值。
+  `TOP_RESOLUTION` — 如果有插槽解析列表，返回解析列表中的第一个值并作为插槽类型值。如果没有解析列表，则返回 null。
如果不指定 `valueSelectionStrategy`，则默认值为 `ORIGINAL_VALUE`。  
类型：字符串  
有效值：`ORIGINAL_VALUE | TOP_RESOLUTION`  
必需：否

## 响应语法
<a name="API_PutSlotType_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "checksum": "string",
   "createdDate": number,
   "createVersion": boolean,
   "description": "string",
   "enumerationValues": [ 
      { 
         "synonyms": [ "string" ],
         "value": "string"
      }
   ],
   "lastUpdatedDate": number,
   "name": "string",
   "parentSlotTypeSignature": "string",
   "slotTypeConfigurations": [ 
      { 
         "regexConfiguration": { 
            "pattern": "string"
         }
      }
   ],
   "valueSelectionStrategy": "string",
   "version": "string"
}
```

## 响应元素
<a name="API_PutSlotType_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [checksum](#API_PutSlotType_ResponseSyntax) **   <a name="lex-PutSlotType-response-checksum"></a>
插槽类型的 `$LATEST` 版本的校验和。  
类型：字符串

 ** [createdDate](#API_PutSlotType_ResponseSyntax) **   <a name="lex-PutSlotType-response-createdDate"></a>
插槽类型的创建日期。  
类型：时间戳

 ** [createVersion](#API_PutSlotType_ResponseSyntax) **   <a name="lex-PutSlotType-response-createVersion"></a>
 `True`（如果创建了新版本的插槽类型）。如果请求中未指定 `createVersion` 字段，则在响应中将 `createVersion` 字段设置为 false。  
类型：布尔值

 ** [description](#API_PutSlotType_ResponseSyntax) **   <a name="lex-PutSlotType-response-description"></a>
槽类型的描述。  
类型：字符串  
长度限制：最小长度为 0。最大长度为 200。

 ** [enumerationValues](#API_PutSlotType_ResponseSyntax) **   <a name="lex-PutSlotType-response-enumerationValues"></a>
定义插槽类型可采用值的 `EnumerationValue` 对象的列表。  
类型：[EnumerationValue](API_EnumerationValue.md) 对象数组  
数组成员：最少 0 个物品。最多 10000 项。

 ** [lastUpdatedDate](#API_PutSlotType_ResponseSyntax) **   <a name="lex-PutSlotType-response-lastUpdatedDate"></a>
插槽类型的更新日期。创建插槽类型时，创建日期和上次更新日期相同。  
类型：时间戳

 ** [name](#API_PutSlotType_ResponseSyntax) **   <a name="lex-PutSlotType-response-name"></a>
槽类型的名称。  
类型：字符串  
长度约束：最小长度为 1。最大长度为 100。  
模式：`^([A-Za-z]_?)+$`

 ** [parentSlotTypeSignature](#API_PutSlotType_ResponseSyntax) **   <a name="lex-PutSlotType-response-parentSlotTypeSignature"></a>
用作此插槽类型的父级的内置插槽类型。  
类型：字符串  
长度约束：最小长度为 1。最大长度为 100。  
模式：`^((AMAZON\.)_?|[A-Za-z]_?)+`

 ** [slotTypeConfigurations](#API_PutSlotType_ResponseSyntax) **   <a name="lex-PutSlotType-response-slotTypeConfigurations"></a>
扩展父级内置插槽类型的配置信息。  
类型：[SlotTypeConfiguration](API_SlotTypeConfiguration.md) 对象数组  
数组成员：最少 0 个物品。最多 10 个物品。

 ** [valueSelectionStrategy](#API_PutSlotType_ResponseSyntax) **   <a name="lex-PutSlotType-response-valueSelectionStrategy"></a>
Amazon Lex 用来确定插槽值的插槽解析策略。有关更多信息，请参阅 [PutSlotType](#API_PutSlotType)。  
类型：字符串  
有效值：`ORIGINAL_VALUE | TOP_RESOLUTION`

 ** [version](#API_PutSlotType_ResponseSyntax) **   <a name="lex-PutSlotType-response-version"></a>
插槽类型的版本。对于新的插槽类型，版本始终为 `$LATEST`。  
类型：字符串  
长度限制：最小长度为 1。长度上限为 64。  
模式：`\$LATEST|[0-9]+`

## 错误
<a name="API_PutSlotType_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** ConflictException **   
 处理请求时出现冲突。请再次尝试您的请求。  
HTTP 状态代码：409

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** PreconditionFailedException **   
 您尝试更改的资源的校验和与请求中的校验和不匹配。检查资源的校验和并重试。  
HTTP 状态代码：412

## 另请参阅
<a name="API_PutSlotType_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/PutSlotType) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/PutSlotType) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/PutSlotType) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/PutSlotType) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/PutSlotType) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/PutSlotType) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/PutSlotType) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/PutSlotType) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/PutSlotType) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/PutSlotType) 

# StartImport
<a name="API_StartImport"></a>

启动作业以将资源导入到 Amazon Lex 中。

## 请求语法
<a name="API_StartImport_RequestSyntax"></a>

```
POST /imports/ HTTP/1.1
Content-type: application/json

{
   "mergeStrategy": "string",
   "payload": blob,
   "resourceType": "string",
   "tags": [ 
      { 
         "key": "string",
         "value": "string"
      }
   ]
}
```

## URI 请求参数
<a name="API_StartImport_RequestParameters"></a>

该请求不使用任何 URI 参数。

## 请求正文
<a name="API_StartImport_RequestBody"></a>

请求接受采用 JSON 格式的以下数据。

 ** [mergeStrategy](#API_StartImport_RequestSyntax) **   <a name="lex-StartImport-request-mergeStrategy"></a>
指定当存在同名的现有资源时，应采取的 `StartImport` 操作。  
+ FAIL\$1ON\$1CONFLICT — 导入文件中的资源与现有资源发生第一次冲突时，导入操作将停止。导致冲突的资源名称位于对 `GetImport` 操作的响应的 `failureReason` 字段中。

  OVERWRITE\$1LATEST — 即使与现有资源发生冲突，导入操作也会继续进行。现有资源的 \$1LASTEST 版本会被导入文件中的数据覆盖。
类型：字符串  
有效值：`OVERWRITE_LATEST | FAIL_ON_CONFLICT`  
是否必需：是

 ** [payload](#API_StartImport_RequestSyntax) **   <a name="lex-StartImport-request-payload"></a>
二进制格式的 zip 存档。存档应包含一个文件：一个包含要导入的资源的 JSON 文件。资源应与在 `resourceType` 字段中指定的类型相匹配。  
类型：Base64 编码的二进制数据对象  
是否必需：是

 ** [resourceType](#API_StartImport_RequestSyntax) **   <a name="lex-StartImport-request-resourceType"></a>
指定要导出的资源的类型。每种资源还会导出它所依赖的任何资源。  
+ 机器人会导出依赖的意图。
+ 意图会导出依赖的插槽类型。
类型：字符串  
有效值：`BOT | INTENT | SLOT_TYPE`  
是否必需：是

 ** [tags](#API_StartImport_RequestSyntax) **   <a name="lex-StartImport-request-tags"></a>
要添加到导入的机器人的标签列表。您只能在导入机器人时添加标签，不能为意图或插槽类型添加标签。  
类型：[Tag](API_Tag.md) 对象数组  
数组成员：最少 0 个物品。最多 200 项。  
必需：否

## 响应语法
<a name="API_StartImport_ResponseSyntax"></a>

```
HTTP/1.1 201
Content-type: application/json

{
   "createdDate": number,
   "importId": "string",
   "importStatus": "string",
   "mergeStrategy": "string",
   "name": "string",
   "resourceType": "string",
   "tags": [ 
      { 
         "key": "string",
         "value": "string"
      }
   ]
}
```

## 响应元素
<a name="API_StartImport_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 201 响应。

服务以 JSON 格式返回的以下数据。

 ** [createdDate](#API_StartImport_ResponseSyntax) **   <a name="lex-StartImport-response-createdDate"></a>
请求导入作业的日期和时间的时间戳。  
类型：时间戳

 ** [importId](#API_StartImport_ResponseSyntax) **   <a name="lex-StartImport-response-importId"></a>
特定导入作业的标识符。  
类型：字符串

 ** [importStatus](#API_StartImport_ResponseSyntax) **   <a name="lex-StartImport-response-importStatus"></a>
导入作业的状态。如果状态为 `FAILED`，则可以使用 `GetImport` 操作获取失败的原因。  
类型：字符串  
有效值：`IN_PROGRESS | COMPLETE | FAILED`

 ** [mergeStrategy](#API_StartImport_ResponseSyntax) **   <a name="lex-StartImport-response-mergeStrategy"></a>
发生合并冲突时要执行的操作。  
类型：字符串  
有效值：`OVERWRITE_LATEST | FAIL_ON_CONFLICT`

 ** [name](#API_StartImport_ResponseSyntax) **   <a name="lex-StartImport-response-name"></a>
提供给导入作业的名称。  
类型：字符串  
长度约束：最小长度为 1。最大长度为 100。  
模式：`[a-zA-Z_]+`

 ** [resourceType](#API_StartImport_ResponseSyntax) **   <a name="lex-StartImport-response-resourceType"></a>
要导入的资源的类型。  
类型：字符串  
有效值：`BOT | INTENT | SLOT_TYPE`

 ** [tags](#API_StartImport_ResponseSyntax) **   <a name="lex-StartImport-response-tags"></a>
添加到导入的机器人的标签列表。  
类型：[Tag](API_Tag.md) 对象数组  
数组成员：最少 0 个物品。最多 200 项。

## 错误
<a name="API_StartImport_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

## 另请参阅
<a name="API_StartImport_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/StartImport) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/StartImport) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/StartImport) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/StartImport) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/StartImport) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/StartImport) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/StartImport) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/StartImport) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/StartImport) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/StartImport) 

# StartMigration
<a name="API_StartMigration"></a>

开始从 Amazon Lex V1 向 Amazon Lex V2 迁移机器人。当您想要利用 Amazon Lex V2 的新功能时，请迁移机器人。

有关更多信息，请参阅 *Amazon Lex 开发人员指南*中的[迁移机器人](https://docs.aws.amazon.com/lex/latest/dg/migrate.html)。

## 请求语法
<a name="API_StartMigration_RequestSyntax"></a>

```
POST /migrations HTTP/1.1
Content-type: application/json

{
   "migrationStrategy": "string",
   "v1BotName": "string",
   "v1BotVersion": "string",
   "v2BotName": "string",
   "v2BotRole": "string"
}
```

## URI 请求参数
<a name="API_StartMigration_RequestParameters"></a>

该请求不使用任何 URI 参数。

## 请求正文
<a name="API_StartMigration_RequestBody"></a>

请求接受采用 JSON 格式的以下数据。

 ** [migrationStrategy](#API_StartMigration_RequestSyntax) **   <a name="lex-StartMigration-request-migrationStrategy"></a>
用于进行迁移的策略。  
+  `CREATE_NEW` — 创建新的 Amazon Lex V2 机器人并将 Amazon Lex V1 机器人迁移到新机器人。
+  `UPDATE_EXISTING` — 覆盖现有的 Amazon Lex V2 机器人元数据和正在迁移的区域设置。它不会更改 Amazon Lex V2 机器人中的任何其他区域设置。如果该区域设置不存在，则会在 Amazon Lex V2 机器人中创建一个新的区域设置。
类型：字符串  
有效值：`CREATE_NEW | UPDATE_EXISTING`  
是否必需：是

 ** [v1BotName](#API_StartMigration_RequestSyntax) **   <a name="lex-StartMigration-request-v1BotName"></a>
要迁移到 Amazon Lex V2 的 Amazon Lex V1 机器人的名称。  
类型：字符串  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`  
是否必需：是

 ** [v1BotVersion](#API_StartMigration_RequestSyntax) **   <a name="lex-StartMigration-request-v1BotVersion"></a>
要迁移到 Amazon Lex V2 的机器人的版本。您可以迁移 `$LATEST` 版本以及任何编号的版本。  
类型：字符串  
长度限制：最小长度为 1。长度上限为 64。  
模式：`\$LATEST|[0-9]+`  
是否必需：是

 ** [v2BotName](#API_StartMigration_RequestSyntax) **   <a name="lex-StartMigration-request-v2BotName"></a>
要将 Amazon Lex V1 机器人迁移到其中的 Amazon Lex V2 的名称。  
+ 如果 Amazon Lex V2 机器人不存在，则必须使用 `CREATE_NEW` 迁移策略。
+ 如果 Amazon Lex V2 机器人存在，则必须使用 `UPDATE_EXISTING` 迁移策略来更改 Amazon Lex V2 机器人的内容。
类型：字符串  
长度约束：最小长度为 1。最大长度为 100。  
模式：`^([0-9a-zA-Z][_-]?)+$`  
是否必需：是

 ** [v2BotRole](#API_StartMigration_RequestSyntax) **   <a name="lex-StartMigration-request-v2BotRole"></a>
Amazon Lex 用来运行 Amazon Lex V2 机器人的 IAM 角色。  
类型：字符串  
长度约束：最小长度为 20。最大长度为 2048。  
模式：`^arn:[\w\-]+:iam::[\d]{12}:role/.+$`  
必需：是

## 响应语法
<a name="API_StartMigration_ResponseSyntax"></a>

```
HTTP/1.1 202
Content-type: application/json

{
   "migrationId": "string",
   "migrationStrategy": "string",
   "migrationTimestamp": number,
   "v1BotLocale": "string",
   "v1BotName": "string",
   "v1BotVersion": "string",
   "v2BotId": "string",
   "v2BotRole": "string"
}
```

## 响应元素
<a name="API_StartMigration_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 202 响应。

服务以 JSON 格式返回以下数据。

 ** [migrationId](#API_StartMigration_ResponseSyntax) **   <a name="lex-StartMigration-response-migrationId"></a>
Amazon Lex 为迁移分配的唯一标识符。  
类型：字符串  
长度限制：固定长度为 10。  
模式：`^[0-9a-zA-Z]+$`

 ** [migrationStrategy](#API_StartMigration_ResponseSyntax) **   <a name="lex-StartMigration-response-migrationStrategy"></a>
用于进行迁移的策略。  
类型：字符串  
有效值：`CREATE_NEW | UPDATE_EXISTING`

 ** [migrationTimestamp](#API_StartMigration_ResponseSyntax) **   <a name="lex-StartMigration-response-migrationTimestamp"></a>
启动迁移的日期和时间。  
类型：时间戳

 ** [v1BotLocale](#API_StartMigration_ResponseSyntax) **   <a name="lex-StartMigration-response-v1BotLocale"></a>
Amazon Lex V1 机器人使用的区域设置。  
类型：字符串  
有效值：`de-DE | en-AU | en-GB | en-IN | en-US | es-419 | es-ES | es-US | fr-FR | fr-CA | it-IT | ja-JP | ko-KR`

 ** [v1BotName](#API_StartMigration_ResponseSyntax) **   <a name="lex-StartMigration-response-v1BotName"></a>
要迁移到 Amazon Lex V2 的 Amazon Lex V1 机器人的名称。  
类型：字符串  
长度限制：最小长度为 2。最大长度为 50。  
模式：`^([A-Za-z]_?)+$`

 ** [v1BotVersion](#API_StartMigration_ResponseSyntax) **   <a name="lex-StartMigration-response-v1BotVersion"></a>
要迁移到 Amazon Lex V2 的机器人的版本。  
类型：字符串  
长度限制：最小长度为 1。长度上限为 64。  
模式：`\$LATEST|[0-9]+`

 ** [v2BotId](#API_StartMigration_ResponseSyntax) **   <a name="lex-StartMigration-response-v2BotId"></a>
Amazon Lex V2 机器人的唯一标识符。  
类型：字符串  
长度限制：固定长度为 10。  
模式：`^[0-9a-zA-Z]+$`

 ** [v2BotRole](#API_StartMigration_ResponseSyntax) **   <a name="lex-StartMigration-response-v2BotRole"></a>
Amazon Lex 用来运行 Amazon Lex V2 机器人的 IAM 角色。  
类型：字符串  
长度约束：最小长度为 20。最大长度为 2048。  
模式：`^arn:[\w\-]+:iam::[\d]{12}:role/.+$`

## 错误
<a name="API_StartMigration_Errors"></a>

 ** AccessDeniedException **   
您的 IAM 用户或角色无权调用迁移机器人 APIs 所需的 Amazon Lex V2。  
HTTP 状态代码：403

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_StartMigration_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/StartMigration) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/StartMigration) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/StartMigration) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/StartMigration) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/StartMigration) 
+  [AWS JavaScript V3 版软件开发工具包](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/StartMigration) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/StartMigration) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/StartMigration) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/StartMigration) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/StartMigration) 

# TagResource
<a name="API_TagResource"></a>

将指定的标签添加到指定的资源中。如果标签键已经存在，则会用新值替换现有的值。

## 请求语法
<a name="API_TagResource_RequestSyntax"></a>

```
POST /tags/resourceArn HTTP/1.1
Content-type: application/json

{
   "tags": [ 
      { 
         "key": "string",
         "value": "string"
      }
   ]
}
```

## URI 请求参数
<a name="API_TagResource_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [resourceArn](#API_TagResource_RequestSyntax) **   <a name="lex-TagResource-request-uri-resourceArn"></a>
要标记的机器人、机器人别名或机器人通道的 Amazon 资源名称 (ARN)。  
长度限制：最小长度为 1。最大长度为 1011。  
是否必需：是

## 请求体
<a name="API_TagResource_RequestBody"></a>

请求接受采用 JSON 格式的以下数据。

 ** [tags](#API_TagResource_RequestSyntax) **   <a name="lex-TagResource-request-tags"></a>
要添加到资源的标签键的列表。如果标签键已经存在，则会用新值替换现有的值。  
类型：[Tag](API_Tag.md) 对象数组  
数组成员：最少 0 个物品。最多 200 项。  
是否必需：是

## 响应语法
<a name="API_TagResource_ResponseSyntax"></a>

```
HTTP/1.1 204
```

## 响应元素
<a name="API_TagResource_ResponseElements"></a>

如果此操作成功，则该服务会发送回带有空 HTTP 正文的 HTTP 204 响应。

## 错误
<a name="API_TagResource_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** ConflictException **   
 处理请求时出现冲突。请再次尝试您的请求。  
HTTP 状态代码：409

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_TagResource_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/TagResource) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/TagResource) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/TagResource) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/TagResource) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/TagResource) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/TagResource) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/TagResource) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/TagResource) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/TagResource) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/TagResource) 

# UntagResource
<a name="API_UntagResource"></a>

从机器人、机器人别名或机器人通道中删除标签。

## 请求语法
<a name="API_UntagResource_RequestSyntax"></a>

```
DELETE /tags/resourceArn?tagKeys=tagKeys HTTP/1.1
```

## URI 请求参数
<a name="API_UntagResource_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [resourceArn](#API_UntagResource_RequestSyntax) **   <a name="lex-UntagResource-request-uri-resourceArn"></a>
要从中删除标签的资源的 Amazon 资源名称 (ARN)。  
长度限制：最小长度为 1。最大长度为 1011。  
是否必需：是

 ** [tagKeys](#API_UntagResource_RequestSyntax) **   <a name="lex-UntagResource-request-uri-tagKeys"></a>
要从资源中删除的标签键的列表。如果资源上不存在标签键，则会将其忽略。  
数组成员：最少 0 个物品。最多 200 项。  
长度限制：最小长度为 1。最大长度为 128。  
是否必需：是

## 请求体
<a name="API_UntagResource_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_UntagResource_ResponseSyntax"></a>

```
HTTP/1.1 204
```

## 响应元素
<a name="API_UntagResource_ResponseElements"></a>

如果此操作成功，则该服务会发送回带有空 HTTP 正文的 HTTP 204 响应。

## 错误
<a name="API_UntagResource_Errors"></a>

 ** BadRequestException **   
请求格式不正确。例如，值无效或必填字段未填充。检查字段值，然后重试。  
HTTP 状态代码：400

 ** ConflictException **   
 处理请求时出现冲突。请再次尝试您的请求。  
HTTP 状态代码：409

 ** InternalFailureException **   
出现内部 Amazon Lex 错误。请再次尝试您的请求。  
HTTP 状态代码：500

 ** LimitExceededException **   
请求超出了限制。请再次尝试您的请求。  
HTTP 状态代码：429

 ** NotFoundException **   
找不到在请求中指定的资源。检查资源并重试。  
HTTP 状态代码：404

## 另请参阅
<a name="API_UntagResource_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/UntagResource) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/lex-models-2017-04-19/UntagResource) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/lex-models-2017-04-19/UntagResource) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/UntagResource) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/UntagResource) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/lex-models-2017-04-19/UntagResource) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/lex-models-2017-04-19/UntagResource) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/UntagResource) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/lex-models-2017-04-19/UntagResource) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/lex-models-2017-04-19/UntagResource) 

# Amazon Lex 运行时服务
<a name="API_Operations_Amazon_Lex_Runtime_Service"></a>

Amazon Lex 运行时服务支持以下操作：
+  [DeleteSession](API_runtime_DeleteSession.md) 
+  [GetSession](API_runtime_GetSession.md) 
+  [PostContent](API_runtime_PostContent.md) 
+  [PostText](API_runtime_PostText.md) 
+  [PutSession](API_runtime_PutSession.md) 

# DeleteSession
<a name="API_runtime_DeleteSession"></a>

删除指定自动程序、别名和用户 ID 的会话信息。

## 请求语法
<a name="API_runtime_DeleteSession_RequestSyntax"></a>

```
DELETE /bot/botName/alias/botAlias/user/userId/session HTTP/1.1
```

## URI 请求参数
<a name="API_runtime_DeleteSession_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [botAlias](#API_runtime_DeleteSession_RequestSyntax) **   <a name="lex-runtime_DeleteSession-request-uri-botAlias"></a>
包含会话数据的机器人的使用中别名。  
是否必需：是

 ** [botName](#API_runtime_DeleteSession_RequestSyntax) **   <a name="lex-runtime_DeleteSession-request-uri-botName"></a>
包含会话数据的机器人的名称。  
是否必需：是

 ** [userId](#API_runtime_DeleteSession_RequestSyntax) **   <a name="lex-runtime_DeleteSession-request-uri-userId"></a>
与会话数据关联的用户的标识符。  
长度限制：最小长度为 2。最大长度为 100。  
模式：`[0-9a-zA-Z._:-]+`  
必需：是

## 请求体
<a name="API_runtime_DeleteSession_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_runtime_DeleteSession_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "botAlias": "string",
   "botName": "string",
   "sessionId": "string",
   "userId": "string"
}
```

## 响应元素
<a name="API_runtime_DeleteSession_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [botAlias](#API_runtime_DeleteSession_ResponseSyntax) **   <a name="lex-runtime_DeleteSession-response-botAlias"></a>
与会话数据关联的机器人的使用中别名。  
类型：字符串

 ** [botName](#API_runtime_DeleteSession_ResponseSyntax) **   <a name="lex-runtime_DeleteSession-response-botName"></a>
与会话关联的机器人的名称。  
类型：字符串

 ** [sessionId](#API_runtime_DeleteSession_ResponseSyntax) **   <a name="lex-runtime_DeleteSession-response-sessionId"></a>
会话的唯一标识符。  
类型：字符串

 ** [userId](#API_runtime_DeleteSession_ResponseSyntax) **   <a name="lex-runtime_DeleteSession-response-userId"></a>
客户端应用程序用户的 ID。  
类型：字符串  
长度限制：最小长度为 2。最大长度为 100。  
模式：`[0-9a-zA-Z._:-]+`

## 错误
<a name="API_runtime_DeleteSession_Errors"></a>

 ** BadRequestException **   
 请求验证失败，上下文中没有可用的消息，或者机器人构建失败、仍在进行中或者包含未构建的更改。  
HTTP 状态代码：400

 ** ConflictException **   
 两个客户端使用相同的 AWS 账户、Amazon Lex 机器人和用户 ID。  
HTTP 状态代码：409

 ** InternalFailureException **   
内部服务错误。重试调用。  
HTTP 状态代码：500

 ** LimitExceededException **   
已超出限制。  
HTTP 状态代码：429

 ** NotFoundException **   
未找到所引用的资源（例如 Amazon Lex 机器人或别名）。  
HTTP 状态代码：404

## 另请参阅
<a name="API_runtime_DeleteSession_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/runtime.lex-2016-11-28/DeleteSession) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/runtime.lex-2016-11-28/DeleteSession) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/runtime.lex-2016-11-28/DeleteSession) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/runtime.lex-2016-11-28/DeleteSession) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/runtime.lex-2016-11-28/DeleteSession) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/runtime.lex-2016-11-28/DeleteSession) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/runtime.lex-2016-11-28/DeleteSession) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/runtime.lex-2016-11-28/DeleteSession) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/runtime.lex-2016-11-28/DeleteSession) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/runtime.lex-2016-11-28/DeleteSession) 

# GetSession
<a name="API_runtime_GetSession"></a>

返回指定自动程序、别名和用户 ID 的会话信息。

## 请求语法
<a name="API_runtime_GetSession_RequestSyntax"></a>

```
GET /bot/botName/alias/botAlias/user/userId/session/?checkpointLabelFilter=checkpointLabelFilter HTTP/1.1
```

## URI 请求参数
<a name="API_runtime_GetSession_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [botAlias](#API_runtime_GetSession_RequestSyntax) **   <a name="lex-runtime_GetSession-request-uri-botAlias"></a>
包含会话数据的机器人的使用中别名。  
是否必需：是

 ** [botName](#API_runtime_GetSession_RequestSyntax) **   <a name="lex-runtime_GetSession-request-uri-botName"></a>
包含会话数据的机器人的名称。  
是否必需：是

 ** [checkpointLabelFilter](#API_runtime_GetSession_RequestSyntax) **   <a name="lex-runtime_GetSession-request-uri-checkpointLabelFilter"></a>
用于筛选 `recentIntentSummaryView` 结构中返回的意图的字符串。  
指定过滤器时，仅返回其 `checkpointLabel` 字段设置为该字符串的意图。  
长度约束：最小长度为 1。最大长度为 255。  
模式：`[a-zA-Z0-9-]+`

 ** [userId](#API_runtime_GetSession_RequestSyntax) **   <a name="lex-runtime_GetSession-request-uri-userId"></a>
客户端应用程序用户的 ID。Amazon Lex 使用它来识别用户与您的机器人的对话。  
长度限制：最小长度为 2。最大长度为 100。  
模式：`[0-9a-zA-Z._:-]+`  
必需：是

## 请求体
<a name="API_runtime_GetSession_RequestBody"></a>

该请求没有请求正文。

## 响应语法
<a name="API_runtime_GetSession_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "activeContexts": [ 
      { 
         "name": "string",
         "parameters": { 
            "string" : "string" 
         },
         "timeToLive": { 
            "timeToLiveInSeconds": number,
            "turnsToLive": number
         }
      }
   ],
   "dialogAction": { 
      "fulfillmentState": "string",
      "intentName": "string",
      "message": "string",
      "messageFormat": "string",
      "slots": { 
         "string" : "string" 
      },
      "slotToElicit": "string",
      "type": "string"
   },
   "recentIntentSummaryView": [ 
      { 
         "checkpointLabel": "string",
         "confirmationStatus": "string",
         "dialogActionType": "string",
         "fulfillmentState": "string",
         "intentName": "string",
         "slots": { 
            "string" : "string" 
         },
         "slotToElicit": "string"
      }
   ],
   "sessionAttributes": { 
      "string" : "string" 
   },
   "sessionId": "string"
}
```

## 响应元素
<a name="API_runtime_GetSession_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [activeContexts](#API_runtime_GetSession_ResponseSyntax) **   <a name="lex-runtime_GetSession-response-activeContexts"></a>
会话的活动上下文列表。可以在履行意图时设置上下文，也可以通过调用 `PostContent`、`PostText` 或 `PutSession` 操作来设置上下文。  
您可以使用上下文来控制可以跟进意图的意图，也可以修改应用程序的操作。  
类型：[ActiveContext](API_runtime_ActiveContext.md) 对象数组  
数组成员：最少 0 个物品。最多 20 个项目。

 ** [dialogAction](#API_runtime_GetSession_ResponseSyntax) **   <a name="lex-runtime_GetSession-response-dialogAction"></a>
描述机器人的当前状态。  
类型：[DialogAction](API_runtime_DialogAction.md) 对象

 ** [recentIntentSummaryView](#API_runtime_GetSession_ResponseSyntax) **   <a name="lex-runtime_GetSession-response-recentIntentSummaryView"></a>
有关会话中使用的意图的一系列信息。系列最多可以包含三个摘要。如果会话中使用的意图超过三个，则 `recentIntentSummaryView` 操作将包含有关最近使用的三个意图的信息。  
如果您在请求中设置 `checkpointLabelFilter` 参数，则系列仅包含带有指定标签的意图。  
类型：[IntentSummary](API_runtime_IntentSummary.md) 对象数组  
数组成员：最少 0 个物品。最多 3 项。

 ** [sessionAttributes](#API_runtime_GetSession_ResponseSyntax) **   <a name="lex-runtime_GetSession-response-sessionAttributes"></a>
代表会话特定上下文信息的 key/value 对映射。它包含在 Amazon Lex 与客户端应用程序之间传递的应用程序信息。  
类型：字符串到字符串映射

 ** [sessionId](#API_runtime_GetSession_ResponseSyntax) **   <a name="lex-runtime_GetSession-response-sessionId"></a>
会话的唯一标识符。  
类型：字符串

## 错误
<a name="API_runtime_GetSession_Errors"></a>

 ** BadRequestException **   
 请求验证失败，上下文中没有可用的消息，或者机器人构建失败、仍在进行中或者包含未构建的更改。  
HTTP 状态代码：400

 ** InternalFailureException **   
内部服务错误。重试调用。  
HTTP 状态代码：500

 ** LimitExceededException **   
已超出限制。  
HTTP 状态代码：429

 ** NotFoundException **   
未找到所引用的资源（例如 Amazon Lex 机器人或别名）。  
HTTP 状态代码：404

## 另请参阅
<a name="API_runtime_GetSession_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/runtime.lex-2016-11-28/GetSession) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/runtime.lex-2016-11-28/GetSession) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/runtime.lex-2016-11-28/GetSession) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/runtime.lex-2016-11-28/GetSession) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/runtime.lex-2016-11-28/GetSession) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/runtime.lex-2016-11-28/GetSession) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/runtime.lex-2016-11-28/GetSession) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/runtime.lex-2016-11-28/GetSession) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/runtime.lex-2016-11-28/GetSession) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/runtime.lex-2016-11-28/GetSession) 

# PostContent
<a name="API_runtime_PostContent"></a>

 将用户输入（文本或语音）发送到 Amazon Lex。客户端使用此 API 在运行时向 Amazon Lex 发送文本和音频请求。Amazon Lex 使用其为机器人构建的机器学习模型来解释用户输入。

`PostContent` 操作支持 8kHz 和 16kHz 的音频输入。在电话音频应用中，您可以使用 8kHz 音频来实现更高的语音识别精度。

 在响应中，Amazon Lex 会返回下一条要传达给用户的消息。考虑以下示例消息：
+  对于用户输入“我想要披萨”，Amazon Lex 可能会返回一条响应，其中包含一条引发插槽数据的消息（例如，`PizzaSize`）：“您想要什么尺寸的披萨？”。
+  在用户提供所有披萨订单信息后，Amazon Lex 可能会返回一条消息以获取用户确认：“是否下披萨订单？”。
+  用户对确认提示回答“是”后，Amazon Lex 可能会返回结论语句：“谢谢，已经为您的奶酪披萨下订单。”。

 并非所有 Amazon Lex 消息都需要用户响应。例如，结论语句不需要响应。有些消息只需要“是”或“否”响应。除了 `message` 之外，Amazon Lex 还提供了有关响应中消息的其他上下文，您可以使用这些上下文来增强客户行为，例如显示相应的客户端用户界面。考虑以下示例：
+  如果消息是为了引发插槽数据，Amazon Lex 会返回以下上下文信息：
  +  `x-amz-lex-dialog-state` 标头设置为 `ElicitSlot` 
  +  `x-amz-lex-intent-name` 标头设置为当前上下文中的意图名称 
  +  `x-amz-lex-slot-to-elicit` 标头设置为 `message` 正在引发信息的插槽名称 
  +  `x-amz-lex-slots` 标头设置为使用当前值为意图配置的插槽映射 
+  如果消息是确认提示，则 `x-amz-lex-dialog-state` 标头设置为 `Confirmation`，`x-amz-lex-slot-to-elicit` 标头将被省略。
+  如果消息是为意图配置的澄清提示，表示用户意图未被理解，则 `x-amz-dialog-state` 标头设置为 `ElicitIntent`，`x-amz-slot-to-elicit` 标头将被省略。

 此外，Amazon Lex 还会返回您的应用程序特定的 `sessionAttributes`。有关更多信息，请参阅[管理对话上下文](https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html)。

## 请求语法
<a name="API_runtime_PostContent_RequestSyntax"></a>

```
POST /bot/botName/alias/botAlias/user/userId/content HTTP/1.1
x-amz-lex-session-attributes: sessionAttributes
x-amz-lex-request-attributes: requestAttributes
Content-Type: contentType
Accept: accept
x-amz-lex-active-contexts: activeContexts

inputStream
```

## URI 请求参数
<a name="API_runtime_PostContent_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [accept](#API_runtime_PostContent_RequestSyntax) **   <a name="lex-runtime_PostContent-request-accept"></a>
 您将此值作为 `Accept` HTTP 标头进行传递。  
 根据请求中的 `Accept` HTTP 标头值，Amazon Lex 在响应中返回的消息可以是文本，也可以是语音。  
+  如果值为 `text/plain; charset=utf-8`，则 Amazon Lex 会在响应中返回文本。
+  如果值以 `audio/` 开头，则 Amazon Lex 会在响应中返回语音。Amazon Lex 使用 Amazon Polly 生成语音（使用您在 `Accept` 标头中指定的配置）。例如，如果您将 `audio/mpeg` 指定为值，Amazon Lex 将返回 MPEG 格式的语音。
+ 如果值为 `audio/pcm`，则返回的语音采用 16 位小端序格式的 `audio/pcm`。
+ 以下是接受的值：
  + audio/mpeg
  + audio/ogg
  + audio/pcm
  + text/plain; charset=utf-8
  + audio/\$1（默认值为 mpeg）

 ** [activeContexts](#API_runtime_PostContent_RequestSyntax) **   <a name="lex-runtime_PostContent-request-activeContexts"></a>
请求的活动上下文列表。可以在履行先前的意图时激活上下文，也可以通过在请求中包含上下文来激活上下文，  
如果您未指定上下文列表，Amazon Lex 将使用会话的上下文的当前列表。如果您指定一个空列表，则会话的所有上下文都将被清除。

 ** [botAlias](#API_runtime_PostContent_RequestSyntax) **   <a name="lex-runtime_PostContent-request-uri-botAlias"></a>
Amazon Lex 机器人的别名。  
是否必需：是

 ** [botName](#API_runtime_PostContent_RequestSyntax) **   <a name="lex-runtime_PostContent-request-uri-botName"></a>
Amazon Lex 机器人的名称。  
是否必需：是

 ** [contentType](#API_runtime_PostContent_RequestSyntax) **   <a name="lex-runtime_PostContent-request-contentType"></a>
 您将此值作为 `Content-Type` HTTP 标头进行传递。  
 表示音频格式或文本。标头值必须以下列其中一个前缀开头：  
+ PCM 格式，音频数据必须按小端序字节顺序排列。
  + audio/l16; rate=16000; channels=1
  + audio/x-l16; sample-rate=16000; channel-count=1
  + audio/lpcm；sample-rate=8000；=16；channel-count=1；=false sample-size-bits is-big-endian 
+ Opus 格式
  + audio/ x-cbr-opus-with-preamble；preamble-size=0；bit-rate=256000；=4 frame-size-milliseconds
+ 文本格式
  + text/plain; charset=utf-8
是否必需：是

 ** [requestAttributes](#API_runtime_PostContent_RequestSyntax) **   <a name="lex-runtime_PostContent-request-requestAttributes"></a>
您将此值作为 `x-amz-lex-request-attributes` HTTP 标头进行传递。  
在 Amazon Lex 和客户端应用程序之间传递的特定于请求的信息。该值必须是带有字符串键和值的 JSON 序列化和 base64 编码映射。`requestAttributes` 和 `sessionAttributes` 标头的总大小限制为 12 KB。  
命名空间 `x-amz-lex:` 保留供特殊属性使用。请勿创建带有 `x-amz-lex:` 前缀的任何请求属性。  
有关更多信息，请参阅[设置请求属性](https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-request-attribs)。

 ** [sessionAttributes](#API_runtime_PostContent_RequestSyntax) **   <a name="lex-runtime_PostContent-request-sessionAttributes"></a>
您将此值作为 `x-amz-lex-session-attributes` HTTP 标头进行传递。  
在 Amazon Lex 和客户端应用程序之间传递的特定于应用程序的信息。该值必须是带有字符串键和值的 JSON 序列化和 base64 编码映射。`sessionAttributes` 和 `requestAttributes` 标头的总大小限制为 12 KB。  
有关更多信息，请参阅[设置会话属性](https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-session-attribs)。

 ** [userId](#API_runtime_PostContent_RequestSyntax) **   <a name="lex-runtime_PostContent-request-uri-userId"></a>
客户端应用程序用户的 ID。Amazon Lex 使用它来识别用户与您的机器人的对话。在运行时，每个请求都必须包含 `userID` 字段。  
要决定用于您的应用程序的用户 ID，请考虑以下因素。  
+ `userID` 字段不得包含用户的任何个人身份信息，例如姓名、个人识别号或其他最终用户的个人信息。
+ 如果您希望用户在一台设备上开始对话，然后在另一台设备上继续对话，请使用用户特定的标识符。
+ 如果您希望同一个用户能够在两台不同的设备上进行两次独立的对话，请选择设备特定的标识符。
+ 用户不能与同一个机器人的两个不同版本进行两个独立的对话。例如，用户无法与同一个机器人的 PROD 和 BETA 版本进行对话。如果您预计用户需要与两个不同的版本进行对话（例如，在测试期间），请在用户 ID 中包含机器人别名以将这两个对话分开。
长度限制：最小长度为 2。最大长度为 100。  
模式：`[0-9a-zA-Z._:-]+`  
必需：是

## 请求正文
<a name="API_runtime_PostContent_RequestBody"></a>

请求接受以下二进制数据。

 ** [inputStream](#API_runtime_PostContent_RequestSyntax) **   <a name="lex-runtime_PostContent-request-inputStream"></a>
 用户以 PCM 或 Opus 音频格式或文本格式输入，如 `Content-Type` HTTP 标头中所述。  
您可以将音频数据流式传输到 Amazon Lex，也可以创建本地缓冲区，在发送之前捕获所有音频数据。通常，如果您流式传输音频数据而不是在本地缓冲数据，则性能会更好。  
是否必需：是

## 响应语法
<a name="API_runtime_PostContent_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-Type: contentType
x-amz-lex-intent-name: intentName
x-amz-lex-nlu-intent-confidence: nluIntentConfidence
x-amz-lex-alternative-intents: alternativeIntents
x-amz-lex-slots: slots
x-amz-lex-session-attributes: sessionAttributes
x-amz-lex-sentiment: sentimentResponse
x-amz-lex-message: message
x-amz-lex-encoded-message: encodedMessage
x-amz-lex-message-format: messageFormat
x-amz-lex-dialog-state: dialogState
x-amz-lex-slot-to-elicit: slotToElicit
x-amz-lex-input-transcript: inputTranscript
x-amz-lex-encoded-input-transcript: encodedInputTranscript
x-amz-lex-bot-version: botVersion
x-amz-lex-session-id: sessionId
x-amz-lex-active-contexts: activeContexts

audioStream
```

## 响应元素
<a name="API_runtime_PostContent_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

响应将返回以下 HTTP 标头。

 ** [activeContexts](#API_runtime_PostContent_ResponseSyntax) **   <a name="lex-runtime_PostContent-response-activeContexts"></a>
会话的活动上下文列表。可以在履行意图时设置上下文，也可以通过调用 `PostContent`、`PostText` 或 `PutSession` 操作来设置上下文。  
您可以使用上下文来控制可以跟进意图的意图，也可以修改应用程序的操作。

 ** [alternativeIntents](#API_runtime_PostContent_ResponseSyntax) **   <a name="lex-runtime_PostContent-response-alternativeIntents"></a>
一到四个可能适用于用户意图的替代意图。  
每个替代意图都包括一个分数，该分数表明 Amazon Lex 对意图与用户意图相匹配的信心程度。意图按置信度分数排序。

 ** [botVersion](#API_runtime_PostContent_ResponseSyntax) **   <a name="lex-runtime_PostContent-response-botVersion"></a>
响应对话的机器人的版本。您可以使用此信息来帮助确定机器人的一个版本的性能是否优于另一个版本。  
长度限制：最小长度为 1。长度上限为 64。  
模式：`[0-9]+|\$LATEST`

 ** [contentType](#API_runtime_PostContent_ResponseSyntax) **   <a name="lex-runtime_PostContent-response-contentType"></a>
请求的 `Accept` HTTP 标头中指定的内容类型。

 ** [dialogState](#API_runtime_PostContent_ResponseSyntax) **   <a name="lex-runtime_PostContent-response-dialogState"></a>
标识用户交互的当前状态。Amazon Lex 返回以下任一值作为 `dialogState`。客户可以选择使用此信息来自定义用户界面。  
+  `ElicitIntent` — Amazon Lex 想要引发的用户的意图。考虑以下示例：

   例如，用户可能会说出意图（“我想点披萨”）。如果 Amazon Lex 无法从此言语中推断出用户的意图，它将返回此对话状态。
+  `ConfirmIntent` — Amazon Lex 预计会有“是”或“否”响应。

  例如，Amazon Lex 希望用户在履行意图之前进行确认。用户可能会响应其他信息，而不是简单的“是”或“否”响应。例如，“是，但要做个厚皮披萨”或“否，我想点一份饮品”。Amazon Lex 可以处理此类额外信息（在这些示例中，更新外壳类型槽或将意图从更改 OrderPizza 为 OrderDrink）。
+  `ElicitSlot` — Amazon Lex 期望当前意图的插槽值。

   例如，假设 Amazon Lex 在响应中发送了以下消息：“您想要什么尺寸的披萨？”。用户可能会响应插槽值（例如，“中等”）。用户还可能在响应中提供其他信息（例如，“中厚皮披萨”）。Amazon Lex 可以适当地处理此类额外信息。
+  `Fulfilled` — 表示 Lambda 函数已成功履行意图。
+  `ReadyForFulfillment` — 表示客户必须满足请求。
+  `Failed` — 表示与用户的对话失败。

   发生这种情况的原因可能多种多样，包括用户没有对服务提示做出适当的响应（您可以配置 Amazon Lex 可以提示用户输入特定信息的次数），或者 Lambda 函数无法履行意图。
有效值：`ElicitIntent | ConfirmIntent | ElicitSlot | Fulfilled | ReadyForFulfillment | Failed`

 ** [encodedInputTranscript](#API_runtime_PostContent_ResponseSyntax) **   <a name="lex-runtime_PostContent-response-encodedInputTranscript"></a>
用于处理请求的文本。  
如果输入为音频流，则 `encodedInputTranscript` 字段包含从该音频流中提取的文本。这是经过实际处理以识别目的和槽值的文本。您可以使用该信息来确定 Amazon Lex 是否正确处理了您发送的音频。  
`encodedInputTranscript` 字段采用 base-64 编码。必须先解码该字段，然后才能使用该值。

 ** [encodedMessage](#API_runtime_PostContent_ResponseSyntax) **   <a name="lex-runtime_PostContent-response-encodedMessage"></a>
要传达给用户的消息。消息可以来自机器人的配置或 Lambda 函数。  
如果未使用 Lambda 函数配置意图，或者如果 Lambda 函数在其响应中返回 `Delegate` 作为 `dialogAction.type`，则 Amazon Lex 会决定下一步操作，并根据当前的交互上下文从机器人的配置中选择相应的消息。例如，如果 Amazon Lex 无法理解用户输入，则会使用澄清提示消息。  
创建意图时，您可以将消息分配给群组。将消息分配给群组后，Amazon Lex 会在响应中返回来自每个群组的一条消息。消息字段是一个包含消息的转义的 JSON 字符串。有关返回的 JSON 字符串结构的更多信息，请参阅[受支持的消息格式](howitworks-manage-prompts.md#msg-prompts-formats)。  
如果 Lambda 函数返回消息，则 Amazon Lex 会在响应中将其传递给客户端。  
`encodedMessage` 字段采用 base-64 编码。必须先解码该字段，然后才能使用该值。  
长度限制：最小长度为 1。最大长度为 1366。

 ** [inputTranscript](#API_runtime_PostContent_ResponseSyntax) **   <a name="lex-runtime_PostContent-response-inputTranscript"></a>
 *此标头已被弃用。*  
用于处理请求的文本。  
您只能在 de-DE、en-AU、en-GB、en-US、es-419、es-ES、es-US、fr-CA、fr-FR 和 it-IT 区域设置中使用此字段。在所有其他区域设置中，`inputTranscript` 字段均为空。您应改用 `encodedInputTranscript` 字段。  
如果输入为音频流，则 `inputTranscript` 字段包含从该音频流中提取的文本。这是经过实际处理以识别目的和槽值的文本。您可以使用该信息来确定 Amazon Lex 是否正确处理了您发送的音频。

 ** [intentName](#API_runtime_PostContent_ResponseSyntax) **   <a name="lex-runtime_PostContent-response-intentName"></a>
Amazon Lex 知道的当前用户意图。

 ** [message](#API_runtime_PostContent_ResponseSyntax) **   <a name="lex-runtime_PostContent-response-message"></a>
 *此标头已被弃用。*  
您只能在 de-DE、en-AU、en-GB、en-US、es-419、es-ES、es-US、fr-CA、fr-FR 和 it-IT 区域设置中使用此字段。在所有其他区域设置中，`message` 字段均为空。您应改用 `encodedMessage` 字段。  
要传达给用户的消息。消息可以来自机器人的配置或 Lambda 函数。  
如果未使用 Lambda 函数配置意图，或者如果 Lambda 函数在其响应中返回 `Delegate` 作为 `dialogAction.type`，则 Amazon Lex 会决定下一步操作，并根据当前的交互上下文从机器人的配置中选择相应的消息。例如，如果 Amazon Lex 无法理解用户输入，则会使用澄清提示消息。  
创建意图时，您可以将消息分配给群组。将消息分配给群组后，Amazon Lex 会在响应中返回来自每个群组的一条消息。消息字段是一个包含消息的转义的 JSON 字符串。有关返回的 JSON 字符串结构的更多信息，请参阅[受支持的消息格式](howitworks-manage-prompts.md#msg-prompts-formats)。  
如果 Lambda 函数返回消息，则 Amazon Lex 会在响应中将其传递给客户端。  
长度限制：长度下限为 1。最大长度为 1024。

 ** [messageFormat](#API_runtime_PostContent_ResponseSyntax) **   <a name="lex-runtime_PostContent-response-messageFormat"></a>
响应消息的格式。下列值之一：  
+  `PlainText` — 消息包含 UTF-8 纯文本。
+  `CustomPayload` — 消息是客户端的自定义格式。
+  `SSML` — 消息包含为语音输出设置格式的文本。
+  `Composite` — 消息包含一个转义的 JSON 对象，其中包含一条或多条来自创建意图时消息分配到的群组中的一条或多条消息。
有效值：`PlainText | CustomPayload | SSML | Composite`

 ** [nluIntentConfidence](#API_runtime_PostContent_ResponseSyntax) **   <a name="lex-runtime_PostContent-response-nluIntentConfidence"></a>
提供一个分数，表示 Amazon Lex 对返回的意图是符合用户的意图的信心程度。分数必须介于 0.0 到 1.0 之间。  
分数是相对分数，而不是绝对分数。根据对 Amazon Lex 的改进，分数可能会发生变化。

 ** [sentimentResponse](#API_runtime_PostContent_ResponseSyntax) **   <a name="lex-runtime_PostContent-response-sentimentResponse"></a>
用言语表达的情绪。  
当机器人配置为向 Amazon Comprehend 发送言语以进行情绪分析时，此字段将包含分析结果。

 ** [sessionAttributes](#API_runtime_PostContent_ResponseSyntax) **   <a name="lex-runtime_PostContent-response-sessionAttributes"></a>
 代表会话特定上下文信息的 key/value 对映射。

 ** [sessionId](#API_runtime_PostContent_ResponseSyntax) **   <a name="lex-runtime_PostContent-response-sessionId"></a>
会话的唯一标识符。

 ** [slots](#API_runtime_PostContent_ResponseSyntax) **   <a name="lex-runtime_PostContent-response-slots"></a>
Amazon Lex 在对话期间从用户输入中检测到的零个或零个以上意图插槽值（键值对）的映射。字段采用 base-64 编码。  
Amazon Lex 会创建包含插槽可能值的列表。它返回的值由创建或更新插槽类型时 `valueSelectionStrategy` 所选的值决定。如果 `valueSelectionStrategy` 设置为 `ORIGINAL_VALUE`，并且用户值与插槽值相近，则返回用户提供的值。如果 `valueSelectionStrategy` 设置为 `TOP_RESOLUTION`，Amazon Lex 会返回解决方案列表中的第一个值，如果没有解决方案列表，则返回空值。如果不指定 `valueSelectionStrategy`，则默认值为 `ORIGINAL_VALUE`。

 ** [slotToElicit](#API_runtime_PostContent_ResponseSyntax) **   <a name="lex-runtime_PostContent-response-slotToElicit"></a>
 如果 `dialogState` 值为 `ElicitSlot`，则返回 Amazon Lex 正在为其获取值的插槽的名称。

响应将以下内容作为 HTTP 正文返回。

 ** [audioStream](#API_runtime_PostContent_ResponseSyntax) **   <a name="lex-runtime_PostContent-response-audioStream"></a>
要向用户传达的提示（或语句）。这取决于机器人的配置和上下文。例如，如果 Amazon Lex 不了解用户意图，则会发送为机器人配置的 `clarificationPrompt`。如果意图需要在采取履行操作之前进行确认，则它会发送 `confirmationPrompt`。另一个示例：假设 Lambda 函数成功履行了意图，并向用户发送了一条消息。然后，Amazon Lex 在响应中发送了该消息。

## 错误
<a name="API_runtime_PostContent_Errors"></a>

 ** BadGatewayException **   
要么是 Amazon Lex 机器人仍在构建，要么其中一个依赖服务（Amazon Polly、AWS Lambda）因内部服务错误而失败。  
HTTP 状态代码：502

 ** BadRequestException **   
 请求验证失败，上下文中没有可用的消息，或者机器人构建失败、仍在进行中或者包含未构建的更改。  
HTTP 状态代码：400

 ** ConflictException **   
 两个客户端使用相同的 AWS 账户、Amazon Lex 机器人和用户 ID。  
HTTP 状态代码：409

 ** DependencyFailedException **   
 其中一个依赖项（例如 AWS Lambda 或 Amazon Polly）引发了异常。例如，  
+ 如果 Amazon Lex 没有足够的权限来调用 Lambda 函数。
+ 如果 Lambda 函数的执行时间超过 30 秒。
+ 如果履行 Lambda 函数返回 `Delegate` 对话操作而不删除任何插槽值。
HTTP 状态代码：424

 ** InternalFailureException **   
内部服务错误。重试调用。  
HTTP 状态代码：500

 ** LimitExceededException **   
已超出限制。  
HTTP 状态代码：429

 ** LoopDetectedException **   
不使用此异常。  
HTTP 状态代码：508

 ** NotAcceptableException **   
请求中的接受标头没有有效值。  
HTTP 状态代码：406

 ** NotFoundException **   
未找到所引用的资源（例如 Amazon Lex 机器人或别名）。  
HTTP 状态代码：404

 ** RequestTimeoutException **   
输入的语音太长。  
HTTP 状态代码：408

 ** UnsupportedMediaTypeException **   
内容类型标头 (`PostContent` API) 的值无效。  
HTTP 状态代码：415

## 示例
<a name="API_runtime_PostContent_Examples"></a>

### 示例 1
<a name="API_runtime_PostContent_Example_1"></a>

 在此请求中，URI 标识了机器人 (Traffic)、机器人版本 (\$1LATEST) 和最终用户名 (someuser)。`Content-Type` 标头标识正文中音频的格式。Amazon Lex 还支持其他格式。如有必要，要将音频从一种格式转换为另一种格式，可以使用 SoX 开源软件。您可以通过添加 `Accept` HTTP 标头来指定获取响应的格式。

 在响应中，`x-amz-lex-message` 标头显示了 Amazon Lex 返回的响应。然后，客户端可以向用户发送此响应。相同的消息通过分块编码（根据要求）以 audio/MPEG 格式发送。

#### 示例请求
<a name="API_runtime_PostContent_Example_1_Request"></a>

```
"POST /bot/Traffic/alias/$LATEST/user/someuser/content HTTP/1.1[\r][\n]"
"x-amz-lex-session-attributes: eyJ1c2VyTmFtZSI6IkJvYiJ9[\r][\n]"
"Content-Type: audio/x-l16; channel-count=1; sample-rate=16000f[\r][\n]"
"Accept: audio/mpeg[\r][\n]"
"Host: runtime.lex.us-east-1.amazonaws.com[\r][\n]"
"Authorization: AWS4-HMAC-SHA256 Credential=BLANKED_OUT/20161230/us-east-1/lex/aws4_request, 
SignedHeaders=accept;content-type;host;x-amz-content-sha256;x-amz-date;x-amz-lex-session-attributes, Signature=78ca5b54ea3f64a17ff7522de02cd90a9acd2365b45a9ce9b96ea105bb1c7ec2[\r][\n]"
"X-Amz-Date: 20161230T181426Z[\r][\n]"
"X-Amz-Content-Sha256: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855[\r][\n]"
"Transfer-Encoding: chunked[\r][\n]"
"Connection: Keep-Alive[\r][\n]"
"User-Agent: Apache-HttpClient/4.5.x (Java/1.8.0_112)[\r][\n]"
"Accept-Encoding: gzip,deflate[\r][\n]"
"[\r][\n]"
"1000[\r][\n]"
"[0x7][0x0][0x7][0x0][\n]"
"[0x0][0x7][0x0][0xfc][0xff][\n]"
"[0x0][\n]"
…
```

#### 示例响应
<a name="API_runtime_PostContent_Example_1_Response"></a>

```
"HTTP/1.1 200 OK[\r][\n]"
"x-amzn-RequestId: cc8b34af-cebb-11e6-a35c-55f3a992f28d[\r][\n]"
"x-amz-lex-message: Sorry, can you repeat that?[\r][\n]"
"x-amz-lex-dialog-state: ElicitIntent[\r][\n]"
"x-amz-lex-session-attributes: eyJ1c2VyTmFtZSI6IkJvYiJ9[\r][\n]"
"Content-Type: audio/mpeg[\r][\n]"
"Transfer-Encoding: chunked[\r][\n]"
"Date: Fri, 30 Dec 2016 18:14:28 GMT[\r][\n]"
"[\r][\n]"               
"2000[\r][\n]"
"ID3[0x4][0x0][0x0][0x0][0x0][0x0]#TSSE[0x0][0x0][0x0][0xf][0x0][0x0][0x3]Lavf57.41.100[0x0][0x0][0x0][0x0][0x0][0x0][0x0][0x0][0x0][0x0][0x0][0xff][0xf3]`[0xc4][0x0][0x1b]{[0x8d][0xe8][0x1]C[0x18][0x1][0x0]J[0xe0]`b[0xdd][0xd1][0xb][0xfd][0x11][0xdf][0xfe]";[0xbb][0xbb][0x9f][0xee][0xee][0xee][0xee]|DDD/[0xff][0xff][0xff][0xff]www?D[0xf7]w^?[0xff][0xfa]h[0x88][0x85][0xfe][0x88][0x88][0x88][[0xa2]'[0xff][0xfa]"{[0x9f][0xe8][0x88]]D[0xeb][0xbb][0xbb][0xa2]!u[0xfd][0xdd][0xdf][0x88][0x94][0x0]F[0xef][0xa1]8[0x0][0x82]w[0x88]N[0x0][0x0][0x9b][0xbb][0xe8][0xe
…
```

## 另请参阅
<a name="API_runtime_PostContent_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/runtime.lex-2016-11-28/PostContent) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/runtime.lex-2016-11-28/PostContent) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/runtime.lex-2016-11-28/PostContent) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/runtime.lex-2016-11-28/PostContent) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/runtime.lex-2016-11-28/PostContent) 
+  [AWS JavaScript V3 版软件开发工具包](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/runtime.lex-2016-11-28/PostContent) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/runtime.lex-2016-11-28/PostContent) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/runtime.lex-2016-11-28/PostContent) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/runtime.lex-2016-11-28/PostContent) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/runtime.lex-2016-11-28/PostContent) 

# PostText
<a name="API_runtime_PostText"></a>

将用户输入发送到 Amazon Lex。客户端应用程序可以使用此 API 在运行时向 Amazon Lex 发送请求。Amazon Lex 随后使用其为机器人构建的机器学习模型来解释用户输入。

 在响应中，Amazon Lex 会返回要传达给用户的下一个 `message` 以及要显示的可选 `responseCard`。考虑以下示例消息：
+  对于用户输入 “我想要披萨”，Amazon Lex 可能会返回一条回复，其中包含一条引出槽位数据的消息（例如， PizzaSize）：“你想要什么尺寸的披萨？” 
+  在用户提供所有披萨订单信息后，Amazon Lex 可能会返回一条消息以获取用户确认：“是否可以进到下披萨订单这一步？”。
+  用户对确认提示回答“是”后，Amazon Lex 可能会返回结论语句：“谢谢，已经为您的奶酪披萨下订单。”。

 并非所有 Amazon Lex 消息都需要用户响应。例如，结论语句不需要响应。有些消息只需要“是”或“否”用户响应。除了 `message` 之外，Amazon Lex 还提供了有关响应中消息的其他上下文，您可以使用这些上下文来增强客户行为，例如显示相应的客户端用户界面。这些是响应中的 `slotToElicit`、`dialogState`、`intentName` 和 `slots` 字段。考虑以下示例：
+ 如果消息是为了引发插槽数据，Amazon Lex 会返回以下上下文信息：
  +  `dialogState`设置为 ElicitSlot 
  +  `intentName` 设置为当前上下文中的意图名称 
  +  `slotToElicit` 设置为 `message` 正在引发信息的插槽名称 
  +  `slots` 设置为具有当前已知值的为意图配置的插槽映射 
+  如果消息是确认提示，`dialogState`则设置为 ConfirmIntent `SlotToElicit`且设置为空。
+ 如果消息是表明用户意图未被理解的澄清提示（为意图配置），`dialogState`则设置为 ElicitIntent 且`slotToElicit`设置为空。

 此外，Amazon Lex 还会返回您的应用程序特定的 `sessionAttributes`。有关更多信息，请参阅[管理对话上下文](https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html)。

## 请求语法
<a name="API_runtime_PostText_RequestSyntax"></a>

```
POST /bot/botName/alias/botAlias/user/userId/text HTTP/1.1
Content-type: application/json

{
   "activeContexts": [ 
      { 
         "name": "string",
         "parameters": { 
            "string" : "string" 
         },
         "timeToLive": { 
            "timeToLiveInSeconds": number,
            "turnsToLive": number
         }
      }
   ],
   "inputText": "string",
   "requestAttributes": { 
      "string" : "string" 
   },
   "sessionAttributes": { 
      "string" : "string" 
   }
}
```

## URI 请求参数
<a name="API_runtime_PostText_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [botAlias](#API_runtime_PostText_RequestSyntax) **   <a name="lex-runtime_PostText-request-uri-botAlias"></a>
Amazon Lex 机器人的别名。  
是否必需：是

 ** [botName](#API_runtime_PostText_RequestSyntax) **   <a name="lex-runtime_PostText-request-uri-botName"></a>
Amazon Lex 机器人的名称。  
是否必需：是

 ** [userId](#API_runtime_PostText_RequestSyntax) **   <a name="lex-runtime_PostText-request-uri-userId"></a>
客户端应用程序用户的 ID。Amazon Lex 使用它来识别用户与您的机器人的对话。在运行时，每个请求都必须包含 `userID` 字段。  
要决定用于您的应用程序的用户 ID，请考虑以下因素。  
+ `userID` 字段不得包含用户的任何个人身份信息，例如姓名、个人识别号或其他最终用户的个人信息。
+ 如果您希望用户在一台设备上开始对话，然后在另一台设备上继续对话，请使用用户特定的标识符。
+ 如果您希望同一个用户能够在两台不同的设备上进行两次独立的对话，请选择设备特定的标识符。
+ 用户不能与同一个机器人的两个不同版本进行两个独立的对话。例如，用户无法与同一个机器人的 PROD 和 BETA 版本进行对话。如果您预计用户需要与两个不同的版本进行对话（例如，在测试期间），请在用户 ID 中包含机器人别名以将这两个对话分开。
长度限制：最小长度为 2。最大长度为 100。  
模式：`[0-9a-zA-Z._:-]+`  
必需：是

## 请求体
<a name="API_runtime_PostText_RequestBody"></a>

请求接受采用 JSON 格式的以下数据。

 ** [activeContexts](#API_runtime_PostText_RequestSyntax) **   <a name="lex-runtime_PostText-request-activeContexts"></a>
请求的活动上下文列表。可以在履行先前的意图时激活上下文，也可以通过在请求中包含上下文来激活上下文，  
如果您未指定上下文列表，Amazon Lex 将使用会话的上下文的当前列表。如果您指定一个空列表，则会话的所有上下文都将被清除。  
类型：[ActiveContext](API_runtime_ActiveContext.md) 对象数组  
数组成员：最少 0 个物品。最多 20 个项目。  
必需：否

 ** [inputText](#API_runtime_PostText_RequestSyntax) **   <a name="lex-runtime_PostText-request-inputText"></a>
用户输入的文本（Amazon Lex 会解释此文本）。  
当您使用 AWS CLI 时，您无法在 `--input-text` 参数中传递 URL。改为使用 `--cli-input-json` 参数传递 URL。  
类型：字符串  
长度限制：最小长度为 1。最大长度为 1024。  
是否必需：是

 ** [requestAttributes](#API_runtime_PostText_RequestSyntax) **   <a name="lex-runtime_PostText-request-requestAttributes"></a>
在 Amazon Lex 和客户端应用程序之间传递的特定于请求的信息。  
命名空间 `x-amz-lex:` 保留供特殊属性使用。请勿创建带有 `x-amz-lex:` 前缀的任何请求属性。  
有关更多信息，请参阅[设置请求属性](https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-request-attribs)。  
类型：字符串到字符串映射  
必需：否

 ** [sessionAttributes](#API_runtime_PostText_RequestSyntax) **   <a name="lex-runtime_PostText-request-sessionAttributes"></a>
在 Amazon Lex 和客户端应用程序之间传递的特定于应用程序的信息。  
有关更多信息，请参阅[设置会话属性](https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-session-attribs)。  
类型：字符串到字符串映射  
必需：否

## 响应语法
<a name="API_runtime_PostText_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-type: application/json

{
   "activeContexts": [ 
      { 
         "name": "string",
         "parameters": { 
            "string" : "string" 
         },
         "timeToLive": { 
            "timeToLiveInSeconds": number,
            "turnsToLive": number
         }
      }
   ],
   "alternativeIntents": [ 
      { 
         "intentName": "string",
         "nluIntentConfidence": { 
            "score": number
         },
         "slots": { 
            "string" : "string" 
         }
      }
   ],
   "botVersion": "string",
   "dialogState": "string",
   "intentName": "string",
   "message": "string",
   "messageFormat": "string",
   "nluIntentConfidence": { 
      "score": number
   },
   "responseCard": { 
      "contentType": "string",
      "genericAttachments": [ 
         { 
            "attachmentLinkUrl": "string",
            "buttons": [ 
               { 
                  "text": "string",
                  "value": "string"
               }
            ],
            "imageUrl": "string",
            "subTitle": "string",
            "title": "string"
         }
      ],
      "version": "string"
   },
   "sentimentResponse": { 
      "sentimentLabel": "string",
      "sentimentScore": "string"
   },
   "sessionAttributes": { 
      "string" : "string" 
   },
   "sessionId": "string",
   "slots": { 
      "string" : "string" 
   },
   "slotToElicit": "string"
}
```

## 响应元素
<a name="API_runtime_PostText_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

服务以 JSON 格式返回以下数据。

 ** [activeContexts](#API_runtime_PostText_ResponseSyntax) **   <a name="lex-runtime_PostText-response-activeContexts"></a>
会话的活动上下文列表。可以在履行意图时设置上下文，也可以通过调用 `PostContent`、`PostText` 或 `PutSession` 操作来设置上下文。  
您可以使用上下文来控制可以跟进意图的意图，也可以修改应用程序的操作。  
类型：[ActiveContext](API_runtime_ActiveContext.md) 对象数组  
数组成员：最少 0 个物品。最多 20 个项目。

 ** [alternativeIntents](#API_runtime_PostText_ResponseSyntax) **   <a name="lex-runtime_PostText-response-alternativeIntents"></a>
一到四个可能适用于用户意图的替代意图。  
每个替代意图都包括一个分数，该分数表明 Amazon Lex 对意图与用户意图相匹配的信心程度。意图按置信度分数排序。  
类型：[PredictedIntent](API_runtime_PredictedIntent.md) 对象数组  
数组成员：最多 4 项。

 ** [botVersion](#API_runtime_PostText_ResponseSyntax) **   <a name="lex-runtime_PostText-response-botVersion"></a>
响应对话的机器人的版本。您可以使用此信息来帮助确定机器人的一个版本的性能是否优于另一个版本。  
类型：字符串  
长度限制：最小长度为 1。长度上限为 64。  
模式：`[0-9]+|\$LATEST`

 ** [dialogState](#API_runtime_PostText_ResponseSyntax) **   <a name="lex-runtime_PostText-response-dialogState"></a>
 标识用户交互的当前状态。Amazon Lex 返回以下任一值作为 `dialogState`。客户可以选择使用此信息来自定义用户界面。  
+  `ElicitIntent` — Amazon Lex 想要引发用户意图。

  例如，用户可能会说出意图（“我想点披萨”）。如果 Amazon Lex 无法从此言语中推断出用户的意图，它将返回此对话状态。
+  `ConfirmIntent` — Amazon Lex 预计会有“是”或“否”响应。

   例如，Amazon Lex 希望用户在履行意图之前进行确认。

  用户可能会响应其他信息，而不是简单的“是”或“否”。例如，“是，但要做个厚皮披萨”或“否，我想点一份饮品”。Amazon Lex 可以处理此类额外信息（在这些示例中，更新外壳类型槽值，或者将意图从更改 OrderPizza 为 OrderDrink）。
+  `ElicitSlot` — Amazon Lex 期望当前意图的插槽值。

  例如，假设 Amazon Lex 在响应中发送了以下消息：“您想要什么尺寸的披萨？”。用户可能会响应插槽值（例如，“中等”）。用户还可能在响应中提供其他信息（例如，“中厚皮披萨”）。Amazon Lex 可以适当地处理此类额外信息。
+  `Fulfilled` — 表示为意图配置的 Lambda 函数已成功履行意图。
+  `ReadyForFulfillment` — 传达客户端必须履行意图。
+  `Failed` — 表示与用户的对话失败。

   发生这种情况的原因可能多种多样，包括用户没有对服务提示做出适当的响应（您可以配置 Amazon Lex 可以提示用户输入特定信息的次数），或者 Lambda 函数无法履行意图。
类型：字符串  
有效值：`ElicitIntent | ConfirmIntent | ElicitSlot | Fulfilled | ReadyForFulfillment | Failed`

 ** [intentName](#API_runtime_PostText_ResponseSyntax) **   <a name="lex-runtime_PostText-response-intentName"></a>
Amazon Lex 知道的当前用户意图。  
类型：字符串

 ** [message](#API_runtime_PostText_ResponseSyntax) **   <a name="lex-runtime_PostText-response-message"></a>
要传达给用户的消息。消息可以来自机器人的配置或 Lambda 函数。  
如果未使用 Lambda 函数配置意图，或者如果 Lambda 函数在其响应中返回 `Delegate` 作为 `dialogAction.type`，则 Amazon Lex 会决定下一步的操作方案，并根据当前的交互上下文从机器人的配置中选择相应的消息。例如，如果 Amazon Lex 无法理解用户输入，则会使用澄清提示消息。  
创建意图时，您可以将消息分配给群组。将消息分配给群组后，Amazon Lex 会在响应中返回来自每个群组的一条消息。消息字段是一个包含消息的转义的 JSON 字符串。有关返回的 JSON 字符串结构的更多信息，请参阅[受支持的消息格式](howitworks-manage-prompts.md#msg-prompts-formats)。  
如果 Lambda 函数返回消息，则 Amazon Lex 会在响应中将其传递给客户端。  
类型：字符串  
长度限制：最小长度为 1。最大长度为 1024。

 ** [messageFormat](#API_runtime_PostText_ResponseSyntax) **   <a name="lex-runtime_PostText-response-messageFormat"></a>
响应消息的格式。下列值之一：  
+  `PlainText` — 消息包含 UTF-8 纯文本。
+  `CustomPayload` — 消息是由 Lambda 函数定义的自定义格式。
+  `SSML` — 消息包含为语音输出设置格式的文本。
+  `Composite` — 消息包含一个转义的 JSON 对象，其中包含一条或多条来自创建意图时消息分配到的群组中的一条或多条消息。
类型：字符串  
有效值：`PlainText | CustomPayload | SSML | Composite`

 ** [nluIntentConfidence](#API_runtime_PostText_ResponseSyntax) **   <a name="lex-runtime_PostText-response-nluIntentConfidence"></a>
提供一个分数，表示 Amazon Lex 对返回的意图是符合用户的意图的信心程度。分数必须介于 0.0 到 1.0 之间。有关更多信息，请参阅[置信度分数](https://docs.aws.amazon.com/lex/latest/dg/confidence-scores.html)。  
分数是相对分数，而不是绝对分数。根据对 Amazon Lex 的改进，分数可能会发生变化。  
类型：[IntentConfidence](API_runtime_IntentConfidence.md) 对象

 ** [responseCard](#API_runtime_PostText_ResponseSyntax) **   <a name="lex-runtime_PostText-response-responseCard"></a>
表示用户响应当前提示时必须使用的选项。响应卡可以来自机器人配置（在 Amazon Lex 控制台中，选择插槽旁边的设置按钮）或代码挂钩（Lambda 函数）。  
类型：[ResponseCard](API_runtime_ResponseCard.md) 对象

 ** [sentimentResponse](#API_runtime_PostText_ResponseSyntax) **   <a name="lex-runtime_PostText-response-sentimentResponse"></a>
用言语表达的情绪。  
当机器人配置为向 Amazon Comprehend 发送言语以进行情绪分析时，此字段将包含分析结果。  
类型：[SentimentResponse](API_runtime_SentimentResponse.md) 对象

 ** [sessionAttributes](#API_runtime_PostText_ResponseSyntax) **   <a name="lex-runtime_PostText-response-sessionAttributes"></a>
表示会话特定上下文信息的键值对的映射。  
类型：字符串到字符串映射

 ** [sessionId](#API_runtime_PostText_ResponseSyntax) **   <a name="lex-runtime_PostText-response-sessionId"></a>
会话的唯一标识符。  
类型：字符串

 ** [slots](#API_runtime_PostText_ResponseSyntax) **   <a name="lex-runtime_PostText-response-slots"></a>
 Amazon Lex 从用户在对话中输入的内容中检测到的意图插槽。  
Amazon Lex 会创建包含插槽可能值的列表。它返回的值由创建或更新插槽类型时 `valueSelectionStrategy` 所选的值决定。如果 `valueSelectionStrategy` 设置为 `ORIGINAL_VALUE`，并且用户值与插槽值相近，则返回用户提供的值。如果 `valueSelectionStrategy` 设置为 `TOP_RESOLUTION`，Amazon Lex 会返回解决方案列表中的第一个值，如果没有解决方案列表，则返回空值。如果不指定 `valueSelectionStrategy`，则默认值为 `ORIGINAL_VALUE`。  
类型：字符串到字符串映射

 ** [slotToElicit](#API_runtime_PostText_ResponseSyntax) **   <a name="lex-runtime_PostText-response-slotToElicit"></a>
如果 `dialogState` 值为 `ElicitSlot`，则返回 Amazon Lex 正在为其获取值的插槽的名称。  
类型：字符串

## 错误
<a name="API_runtime_PostText_Errors"></a>

 ** BadGatewayException **   
要么是 Amazon Lex 机器人仍在构建，要么其中一个依赖服务（Amazon Polly、AWS Lambda）因内部服务错误而失败。  
HTTP 状态代码：502

 ** BadRequestException **   
 请求验证失败，上下文中没有可用的消息，或者机器人构建失败、仍在进行中或者包含未构建的更改。  
HTTP 状态代码：400

 ** ConflictException **   
 两个客户端使用相同的 AWS 账户、Amazon Lex 机器人和用户 ID。  
HTTP 状态代码：409

 ** DependencyFailedException **   
 其中一个依赖项（例如 AWS Lambda 或 Amazon Polly）引发了异常。例如，  
+ 如果 Amazon Lex 没有足够的权限来调用 Lambda 函数。
+ 如果 Lambda 函数的执行时间超过 30 秒。
+ 如果履行 Lambda 函数返回 `Delegate` 对话操作而不删除任何插槽值。
HTTP 状态代码：424

 ** InternalFailureException **   
内部服务错误。重试调用。  
HTTP 状态代码：500

 ** LimitExceededException **   
已超出限制。  
HTTP 状态代码：429

 ** LoopDetectedException **   
不使用此异常。  
HTTP 状态代码：508

 ** NotFoundException **   
未找到所引用的资源（例如 Amazon Lex 机器人或别名）。  
HTTP 状态代码：404

## 另请参阅
<a name="API_runtime_PostText_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/runtime.lex-2016-11-28/PostText) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/runtime.lex-2016-11-28/PostText) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/runtime.lex-2016-11-28/PostText) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/runtime.lex-2016-11-28/PostText) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/runtime.lex-2016-11-28/PostText) 
+  [AWS JavaScript V3 版软件开发工具包](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/runtime.lex-2016-11-28/PostText) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/runtime.lex-2016-11-28/PostText) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/runtime.lex-2016-11-28/PostText) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/runtime.lex-2016-11-28/PostText) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/runtime.lex-2016-11-28/PostText) 

# PutSession
<a name="API_runtime_PutSession"></a>

使用 Amazon Lex 自动程序创建新会话或修改现有会话。使用此操作使您的应用程序能够设置机器人的状态。

有关更多信息，请参阅[管理会话](https://docs.aws.amazon.com/lex/latest/dg/how-session-api.html)。

## 请求语法
<a name="API_runtime_PutSession_RequestSyntax"></a>

```
POST /bot/botName/alias/botAlias/user/userId/session HTTP/1.1
Accept: accept
Content-type: application/json

{
   "activeContexts": [ 
      { 
         "name": "string",
         "parameters": { 
            "string" : "string" 
         },
         "timeToLive": { 
            "timeToLiveInSeconds": number,
            "turnsToLive": number
         }
      }
   ],
   "dialogAction": { 
      "fulfillmentState": "string",
      "intentName": "string",
      "message": "string",
      "messageFormat": "string",
      "slots": { 
         "string" : "string" 
      },
      "slotToElicit": "string",
      "type": "string"
   },
   "recentIntentSummaryView": [ 
      { 
         "checkpointLabel": "string",
         "confirmationStatus": "string",
         "dialogActionType": "string",
         "fulfillmentState": "string",
         "intentName": "string",
         "slots": { 
            "string" : "string" 
         },
         "slotToElicit": "string"
      }
   ],
   "sessionAttributes": { 
      "string" : "string" 
   }
}
```

## URI 请求参数
<a name="API_runtime_PutSession_RequestParameters"></a>

请求使用以下 URI 参数。

 ** [accept](#API_runtime_PutSession_RequestSyntax) **   <a name="lex-runtime_PutSession-request-accept"></a>
Amazon Lex 在响应中返回的消息可以是文本，也可以是语音，取决于此字段的值。  
+ 如果值为 `text/plain; charset=utf-8`，则 Amazon Lex 会在响应中返回文本。
+ 如果值以 `audio/` 开头，则 Amazon Lex 会在响应中返回语音。Amazon Lex 使用 Amazon Polly 按照您指定的配置生成语音。例如，如果您将 `audio/mpeg` 指定为值，Amazon Lex 将返回 MPEG 格式的语音。
+ 如果值为 `audio/pcm`，则返回的语音采用 16 位小端序格式的 `audio/pcm`。
+ 以下是接受的值：
  +  `audio/mpeg` 
  +  `audio/ogg` 
  +  `audio/pcm` 
  +  `audio/*`（默认值为 mpeg）
  +  `text/plain; charset=utf-8` 

 ** [botAlias](#API_runtime_PutSession_RequestSyntax) **   <a name="lex-runtime_PutSession-request-uri-botAlias"></a>
包含会话数据的机器人的使用中别名。  
是否必需：是

 ** [botName](#API_runtime_PutSession_RequestSyntax) **   <a name="lex-runtime_PutSession-request-uri-botName"></a>
包含会话数据的机器人的名称。  
是否必需：是

 ** [userId](#API_runtime_PutSession_RequestSyntax) **   <a name="lex-runtime_PutSession-request-uri-userId"></a>
客户端应用程序用户的 ID。Amazon Lex 使用它来识别用户与您的机器人的对话。  
长度限制：最小长度为 2。最大长度为 100。  
模式：`[0-9a-zA-Z._:-]+`  
必需：是

## 请求体
<a name="API_runtime_PutSession_RequestBody"></a>

请求接受采用 JSON 格式的以下数据。

 ** [activeContexts](#API_runtime_PutSession_RequestSyntax) **   <a name="lex-runtime_PutSession-request-activeContexts"></a>
请求的活动上下文列表。可以在履行先前的意图时激活上下文，也可以通过在请求中包含上下文来激活上下文，  
如果您未指定上下文列表，Amazon Lex 将使用会话的上下文的当前列表。如果您指定一个空列表，则会话的所有上下文都将被清除。  
类型：[ActiveContext](API_runtime_ActiveContext.md) 对象数组  
数组成员：最少 0 个物品。最多 20 个项目。  
必需：否

 ** [dialogAction](#API_runtime_PutSession_RequestSyntax) **   <a name="lex-runtime_PutSession-request-dialogAction"></a>
设置机器人为完成对话而应采取的下一个操作。  
类型：[DialogAction](API_runtime_DialogAction.md) 对象  
必需：否

 ** [recentIntentSummaryView](#API_runtime_PutSession_RequestSyntax) **   <a name="lex-runtime_PutSession-request-recentIntentSummaryView"></a>
该机器人最近的意图摘要。您可以使用意图摘要视图在意图上设置检查点标签并修改意图的属性。您也可以使用它来移除意图摘要对象或向列表中添加意图摘要对象。  
您修改或添加到列表中的意图必须对机器人有意义。例如，意图名称对于机器人而言必须有效。您必须为以下项提供值：  
+  `intentName` 
+ 插槽名称
+  `slotToElict` 
如果您在 `PutSession` 请求中发送 `recentIntentSummaryView` 参数，则新摘要视图的内容将替换旧的摘要视图。例如，如果 `GetSession` 请求在摘要视图中返回三个意图，而您在摘要视图中使用一个意图呼叫 `PutSession`，则对 `GetSession` 的下一个调用将只返回一个意图。  
类型：[IntentSummary](API_runtime_IntentSummary.md) 对象数组  
数组成员：最少 0 个物品。最多 3 项。  
必需：否

 ** [sessionAttributes](#API_runtime_PutSession_RequestSyntax) **   <a name="lex-runtime_PutSession-request-sessionAttributes"></a>
代表会话特定上下文信息的 key/value 对映射。它包含在 Amazon Lex 与客户端应用程序之间传递的应用程序信息。  
类型：字符串到字符串映射  
必需：否

## 响应语法
<a name="API_runtime_PutSession_ResponseSyntax"></a>

```
HTTP/1.1 200
Content-Type: contentType
x-amz-lex-intent-name: intentName
x-amz-lex-slots: slots
x-amz-lex-session-attributes: sessionAttributes
x-amz-lex-message: message
x-amz-lex-encoded-message: encodedMessage
x-amz-lex-message-format: messageFormat
x-amz-lex-dialog-state: dialogState
x-amz-lex-slot-to-elicit: slotToElicit
x-amz-lex-session-id: sessionId
x-amz-lex-active-contexts: activeContexts

audioStream
```

## 响应元素
<a name="API_runtime_PutSession_ResponseElements"></a>

如果此操作成功，则该服务将会发送回 HTTP 200 响应。

响应将返回以下 HTTP 标头。

 ** [activeContexts](#API_runtime_PutSession_ResponseSyntax) **   <a name="lex-runtime_PutSession-response-activeContexts"></a>
会话的活动上下文列表。

 ** [contentType](#API_runtime_PutSession_ResponseSyntax) **   <a name="lex-runtime_PutSession-response-contentType"></a>
请求的 `Accept` HTTP 标头中指定的内容类型。

 ** [dialogState](#API_runtime_PutSession_ResponseSyntax) **   <a name="lex-runtime_PutSession-response-dialogState"></a>
  
+  `ConfirmIntent` — Amazon Lex 预计在履行意图之前会有“是”或“否”响应来确认意图。
+  `ElicitIntent` — Amazon Lex 想要引发的用户的意图。
+  `ElicitSlot` — Amazon Lex 期望当前意图的插槽值。
+  `Failed` — 传达与用户的对话失败。发生这种情况的原因可能多种多样，包括用户没有对服务提示做出适当的响应，或者 Lambda 函数无法履行意图。
+  `Fulfilled` — 表示 Lambda 函数已成功履行意图。
+  `ReadyForFulfillment` — 传达客户端必须履行意图。
有效值：`ElicitIntent | ConfirmIntent | ElicitSlot | Fulfilled | ReadyForFulfillment | Failed`

 ** [encodedMessage](#API_runtime_PutSession_ResponseSyntax) **   <a name="lex-runtime_PutSession-response-encodedMessage"></a>
应向用户显示的下一条消息。  
`encodedMessage` 字段采用 base-64 编码。必须先解码该字段，然后才能使用该值。  
长度限制：最小长度为 1。最大长度为 1366。

 ** [intentName](#API_runtime_PutSession_ResponseSyntax) **   <a name="lex-runtime_PutSession-response-intentName"></a>
当前意图的名称。

 ** [message](#API_runtime_PutSession_ResponseSyntax) **   <a name="lex-runtime_PutSession-response-message"></a>
 *此标头已被弃用。*  
应向用户显示的下一条消息。  
您只能在 de-DE、en-AU、en-GB、en-US、es-419、es-ES、es-US、fr-CA、fr-FR 和 it-IT 区域设置中使用此字段。在所有其他区域设置中，`message` 字段均为空。您应改用 `encodedMessage` 字段。  
长度限制：长度下限为 1。最大长度为 1024。

 ** [messageFormat](#API_runtime_PutSession_ResponseSyntax) **   <a name="lex-runtime_PutSession-response-messageFormat"></a>
响应消息的格式。下列值之一：  
+  `PlainText` — 消息包含 UTF-8 纯文本。
+  `CustomPayload` — 消息是客户端的自定义格式。
+  `SSML` — 消息包含为语音输出设置格式的文本。
+  `Composite` — 消息包含一个转义的 JSON 对象，其中包含一条或多条来自创建意图时消息分配到的群组中的一条或多条消息。
有效值：`PlainText | CustomPayload | SSML | Composite`

 ** [sessionAttributes](#API_runtime_PutSession_ResponseSyntax) **   <a name="lex-runtime_PutSession-response-sessionAttributes"></a>
代表会话特定上下文信息的 key/value 对映射。

 ** [sessionId](#API_runtime_PutSession_ResponseSyntax) **   <a name="lex-runtime_PutSession-response-sessionId"></a>
会话的唯一标识符。

 ** [slots](#API_runtime_PutSession_ResponseSyntax) **   <a name="lex-runtime_PutSession-response-slots"></a>
Amazon Lex 在对话期间从用户输入中检测到的零个或零个以上意图插槽值的映射。  
Amazon Lex 会创建包含插槽可能值的列表。它返回的值由创建或更新插槽类型时 `valueSelectionStrategy` 所选的值决定。如果 `valueSelectionStrategy` 设置为 `ORIGINAL_VALUE`，并且用户值与插槽值相近，则返回用户提供的值。如果 `valueSelectionStrategy` 设置为 `TOP_RESOLUTION`，Amazon Lex 会返回解决方案列表中的第一个值，如果没有解决方案列表，则返回空值。如果不指定 `valueSelectionStrategy`，则默认值为 `ORIGINAL_VALUE`。

 ** [slotToElicit](#API_runtime_PutSession_ResponseSyntax) **   <a name="lex-runtime_PutSession-response-slotToElicit"></a>
如果 `dialogState` 为 `ElicitSlot`，则返回 Amazon Lex 正在为其获取值的插槽的名称。

响应将以下内容作为 HTTP 正文返回。

 ** [audioStream](#API_runtime_PutSession_ResponseSyntax) **   <a name="lex-runtime_PutSession-response-audioStream"></a>
要传达给用户的消息的音频版本。

## 错误
<a name="API_runtime_PutSession_Errors"></a>

 ** BadGatewayException **   
要么是 Amazon Lex 机器人仍在构建，要么其中一个依赖服务（Amazon Polly、AWS Lambda）因内部服务错误而失败。  
HTTP 状态代码：502

 ** BadRequestException **   
 请求验证失败，上下文中没有可用的消息，或者机器人构建失败、仍在进行中或者包含未构建的更改。  
HTTP 状态代码：400

 ** ConflictException **   
 两个客户端使用相同的 AWS 账户、Amazon Lex 机器人和用户 ID。  
HTTP 状态代码：409

 ** DependencyFailedException **   
 其中一个依赖项（例如 AWS Lambda 或 Amazon Polly）引发了异常。例如，  
+ 如果 Amazon Lex 没有足够的权限来调用 Lambda 函数。
+ 如果 Lambda 函数的执行时间超过 30 秒。
+ 如果履行 Lambda 函数返回 `Delegate` 对话操作而不删除任何插槽值。
HTTP 状态代码：424

 ** InternalFailureException **   
内部服务错误。重试调用。  
HTTP 状态代码：500

 ** LimitExceededException **   
已超出限制。  
HTTP 状态代码：429

 ** NotAcceptableException **   
请求中的接受标头没有有效值。  
HTTP 状态代码：406

 ** NotFoundException **   
未找到所引用的资源（例如 Amazon Lex 机器人或别名）。  
HTTP 状态代码：404

## 另请参阅
<a name="API_runtime_PutSession_SeeAlso"></a>

有关以特定语言之一使用此 API 的更多信息 AWS SDKs，请参阅以下内容：
+  [AWS 命令行界面 V2](https://docs.aws.amazon.com/goto/cli2/runtime.lex-2016-11-28/PutSession) 
+  [AWS 适用于.NET 的 SDK V4](https://docs.aws.amazon.com/goto/DotNetSDKV4/runtime.lex-2016-11-28/PutSession) 
+  [AWS 适用于 C\$1\$1 的 SDK](https://docs.aws.amazon.com/goto/SdkForCpp/runtime.lex-2016-11-28/PutSession) 
+  [AWS 适用于 Go v2 的 SDK](https://docs.aws.amazon.com/goto/SdkForGoV2/runtime.lex-2016-11-28/PutSession) 
+  [AWS 适用于 Java 的 SDK V2](https://docs.aws.amazon.com/goto/SdkForJavaV2/runtime.lex-2016-11-28/PutSession) 
+  [AWS JavaScript V3 版 SDK](https://docs.aws.amazon.com/goto/SdkForJavaScriptV3/runtime.lex-2016-11-28/PutSession) 
+  [AWS 适用于 Kotlin 的 SDK](https://docs.aws.amazon.com/goto/SdkForKotlin/runtime.lex-2016-11-28/PutSession) 
+  [AWS 适用于 PHP 的 SDK V3](https://docs.aws.amazon.com/goto/SdkForPHPV3/runtime.lex-2016-11-28/PutSession) 
+  [AWS Python 软件开发工具包](https://docs.aws.amazon.com/goto/boto3/runtime.lex-2016-11-28/PutSession) 
+  [AWS 适用于 Ruby V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForRubyV3/runtime.lex-2016-11-28/PutSession)