支援終止通知：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 Model Building Service 支援下列動作：
+  [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 Runtime Service 支援下列動作：
+  [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 Model Building Service 支援下列動作：
+  [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 Model Building Service 建立的每個 Amazon Lex 機器人，您必須指定您對 Amazon Lex 的使用是否與網站、程式或其他應用程式相關，而該網站、程式或其他應用程式全部或部分針對 13 以下兒童，並在 `false` `childDirected` 欄位中指定 `true` 或 以遵守兒童線上隱私權保護法 (COPPA)。透過`true`在 `childDirected` 欄位中指定 ，您確認使用 Amazon Lex **與**網站、程式或其他應用程式相關，而該網站、程式或其他應用程式全部或部分以 13 以下兒童為目標，且受到 COPPA 的約束。透過`false`在 `childDirected` 欄位中指定 ，您確認 Amazon Lex 的使用與網站、程式或其他應用程式**無關**，而該網站、程式或其他應用程式全部或部分針對 13 以下且受 COPPA 約束的 兒童。您無法為 `childDirected` 欄位指定預設值，該值無法準確反映您對 Amazon Lex 的使用是否與網站、程式或其他應用程式相關，而該網站、程式或其他應用程式是針對或部分針對未滿 13 歲且受 COPPA 規範的 13 歲兒童。  
如果您使用 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>
建立機器人版本的日期。  
類型：Timestamp

 ** [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`版本更新的日期。  
類型：Timestamp

 ** [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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/CreateBotVersion) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/CreateBotVersion) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/CreateBotVersion) 
+  [AWS 適用於 Python 的 SDK](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>
建立意圖的日期。  
類型：Timestamp

 ** [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>
意圖更新的日期。  
類型：Timestamp

 ** [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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/CreateIntentVersion) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/CreateIntentVersion) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/CreateIntentVersion) 
+  [AWS 適用於 Python 的 SDK](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>
槽類型的建立日期。  
類型：Timestamp

 ** [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>
槽類型更新的日期。當您建立資源時，建立日期和上次更新日期相同。  
類型：Timestamp

 ** [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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/CreateSlotTypeVersion) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/CreateSlotTypeVersion) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/CreateSlotTypeVersion) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/DeleteBot) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/DeleteBot) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/DeleteBot) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/DeleteBotAlias) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/DeleteBotAlias) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/DeleteBotAlias) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/DeleteBotChannelAssociation) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/DeleteBotChannelAssociation) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/DeleteBotChannelAssociation) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/DeleteBotVersion) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/DeleteBotVersion) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/DeleteBotVersion) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/DeleteIntent) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/DeleteIntent) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/DeleteIntent) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/DeleteIntentVersion) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/DeleteIntentVersion) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/DeleteIntentVersion) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/DeleteSlotType) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/DeleteSlotType) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/DeleteSlotType) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/DeleteSlotTypeVersion) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/DeleteSlotTypeVersion) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/DeleteSlotTypeVersion) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/DeleteUtterances) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/DeleteUtterances) 
+  [AWS 適用於 Java V2 的 SDK](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/DeleteUtterances) 
+  [AWS 適用於 JavaScript V3 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/DeleteUtterances) 
+  [AWS 適用於 Python 的 SDK](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 Model Building Service 建立的每個 Amazon Lex 機器人，您必須指定您對 Amazon Lex 的使用是否與網站、程式或其他應用程式相關，而該網站、程式或其他應用程式全部或部分針對 13 以下兒童，並在 `false` `childDirected` 欄位中指定 `true` 或 以遵守兒童線上隱私權保護法 (COPPA)。透過`true`在 `childDirected` 欄位中指定 ，您確認使用 Amazon Lex **與**網站、程式或其他應用程式相關，而該網站、程式或其他應用程式全部或部分以 13 以下兒童為目標，且受到 COPPA 的約束。透過`false`在 `childDirected` 欄位中指定 ，您確認 Amazon Lex 的使用與網站、程式或其他應用程式**無關**，而該網站、程式或其他應用程式全部或部分針對 13 以下且受 COPPA 約束的 兒童。您無法為 `childDirected` 欄位指定預設值，該值無法準確反映您對 Amazon Lex 的使用是否與網站、程式或其他應用程式相關，而該網站、程式或其他應用程式是針對或部分針對未滿 13 歲且受 COPPA 規範的 13 歲兒童。  
如果您使用 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>
機器人建立的日期。  
類型：Timestamp

 ** [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>
機器人更新的日期。當您建立資源時，建立日期和上次更新日期相同。  
類型：Timestamp

 ** [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>
在 [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) 回應中傳回替代意圖時`AMAZON.KendraSearchIntent`，決定 Amazon Lex 插入 `AMAZON.FallbackIntent`、 或兩者位置的分數。如果所有意圖的可信度分數都低於此值，`AMAZON.FallbackIntent`則會插入 。只有在為機器人設定時，`AMAZON.KendraSearchIntent`才會插入 。  
類型：Double  
有效範圍：最小值為 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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBot) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBot) 
+  [AWS 適用於 Java V2 的 SDK](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/GetBot) 
+  [AWS 適用於 JavaScript V3 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBot) 
+  [AWS 適用於 Python 的 SDK](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>
建立機器人別名的日期。  
類型：Timestamp

 ** [description](#API_GetBotAlias_ResponseSyntax) **   <a name="lex-GetBotAlias-response-description"></a>
機器人別名的描述。  
類型：字串  
長度限制：長度下限為 0。長度上限為 200。

 ** [lastUpdatedDate](#API_GetBotAlias_ResponseSyntax) **   <a name="lex-GetBotAlias-response-lastUpdatedDate"></a>
機器人別名的更新日期。當您建立資源時，建立日期和上次更新的日期相同。  
類型：Timestamp

 ** [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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBotAlias) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBotAlias) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBotAlias) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBotAliases) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBotAliases) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBotAliases) 
+  [AWS 適用於 Python 的 SDK](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>
機器人與頻道之間的關聯建立日期。  
類型：Timestamp

 ** [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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBotChannelAssociation) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBotChannelAssociation) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBotChannelAssociation) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBotChannelAssociations) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBotChannelAssociations) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBotChannelAssociations) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBots) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBots) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBots) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBotVersions) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBotVersions) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBotVersions) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBuiltinIntent) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBuiltinIntent) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBuiltinIntent) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBuiltinIntents) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBuiltinIntents) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBuiltinIntents) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetBuiltinSlotTypes) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetBuiltinSlotTypes) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetBuiltinSlotTypes) 
+  [AWS 適用於 Python 的 SDK](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。匯出的資源是 ZIP 封存檔，其中包含 JSON 格式的匯出資源。封存的結構可能會變更。您的程式碼不應依賴封存結構。  
類型：字串

 ** [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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetExport) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetExport) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetExport) 
+  [AWS 適用於 Python 的 SDK](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>
建立匯入任務的日期和時間的時間戳記。  
類型：Timestamp

 ** [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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetImport) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetImport) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetImport) 
+  [AWS 適用於 Python 的 SDK](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>
建立意圖的日期。  
類型：Timestamp

 ** [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 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.KendraSearchIntent`意圖連線至 Amazon Kendra 索引。  
類型：[KendraConfiguration](API_KendraConfiguration.md) 物件

 ** [lastUpdatedDate](#API_GetIntent_ResponseSyntax) **   <a name="lex-GetIntent-response-lastUpdatedDate"></a>
意圖更新的日期。當您建立資源時，建立日期和上次更新的日期相同。  
類型：Timestamp

 ** [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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetIntent) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetIntent) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetIntent) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetIntents) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetIntents) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetIntents) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetIntentVersions) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetIntentVersions) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetIntentVersions) 
+  [AWS 適用於 Python 的 SDK](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>
指出遷移的狀態。當狀態為遷移完成`COMPLETE`且機器人可在 Amazon Lex V2 中使用時。可能需要解決提醒和警告，才能完成遷移。  
類型：字串  
有效值:`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>
遷移開始的日期和時間。  
類型：Timestamp

 ** [v1BotLocale](#API_GetMigration_ResponseSyntax) **   <a name="lex-GetMigration-response-v1BotLocale"></a>
Amazon Lex V1 機器人的地區設定已遷移至 Amazon Lex V2。  
類型：字串  
有效值:`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 機器人名稱。 Amazon Lex V2  
類型：字串  
長度限制：長度下限為 2。長度上限為 50。  
模式：`^([A-Za-z]_?)+$`

 ** [v1BotVersion](#API_GetMigration_ResponseSyntax) **   <a name="lex-GetMigration-response-v1BotVersion"></a>
Amazon Lex V1 機器人的版本已遷移至 Amazon Lex V2。  
類型：字串  
長度限制：長度下限為 1。長度上限為 64。  
模式：`\$LATEST|[0-9]+`

 ** [v2BotId](#API_GetMigration_ResponseSyntax) **   <a name="lex-GetMigration-response-v2BotId"></a>
要遷移至 Amazon Lex V1 之 Amazon Lex V2 機器人的唯一識別符。 Amazon Lex V1   
類型：字串  
長度限制：固定長度為 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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetMigration) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetMigration) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetMigration) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetMigrations) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetMigrations) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetMigrations) 
+  [AWS 適用於 Python 的 SDK](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>
槽類型的建立日期。  
類型：Timestamp

 ** [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>
槽類型更新的日期。當您建立資源時，建立日期和上次更新日期相同。  
類型：Timestamp

 ** [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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetSlotType) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetSlotType) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetSlotType) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetSlotTypes) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetSlotTypes) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetSlotTypes) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetSlotTypeVersions) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetSlotTypeVersions) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetSlotTypeVersions) 
+  [AWS 適用於 Python 的 SDK](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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/GetUtterancesView) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/GetUtterancesView) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/GetUtterancesView) 
+  [AWS 適用於 Python 的 SDK](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 Resource Name (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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/ListTagsForResource) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/ListTagsForResource) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/ListTagsForResource) 
+  [AWS 適用於 Python 的 SDK](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` 欄位。  
如果您已定義備用意圖，則不會將取消陳述式傳送給使用者，而是改用備用意圖。如需詳細資訊，請參閱 [ AMAZON.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 Model Building Service 建立的每個 Amazon Lex 機器人，您必須指定您對 Amazon Lex 的使用是否與網站、程式或其他應用程式相關，而該網站、程式或其他應用程式全部或部分針對 13 以下兒童，並在 `false` `childDirected` 欄位中指定 `true` 或 以遵守兒童線上隱私權保護法 (COPPA)。透過`true`在 `childDirected` 欄位中指定 ，您確認使用 Amazon Lex **與**網站、程式或其他應用程式相關，而該網站、程式或其他應用程式全部或部分以 13 以下兒童為目標，且受到 COPPA 的約束。透過`false`在 `childDirected` 欄位中指定 ，您確認 Amazon Lex 的使用與網站、程式或其他應用程式**無關**，而該網站、程式或其他應用程式全部或部分針對 13 以下且受 COPPA 約束的 兒童。您無法為 `childDirected` 欄位指定預設值，該值無法準確反映您對 Amazon Lex 的使用是否與網站、程式或其他應用程式相關，而該網站、程式或其他應用程式是針對或部分針對未滿 13 歲且受 COPPA 規範的 13 歲兒童。  
如果您使用 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`欄位中定義的次數，則會叫用它。如需詳細資訊，請參閱 [ AMAZON.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>
決定在 [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) 回應中傳回替代意圖時`AMAZON.FallbackIntent`，Amazon Lex 將插入 `AMAZON.KendraSearchIntent`、 或兩者的閾值。 `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` 操作的回應將是：  
+ AMAZON.FallbackIntent
+ IntentA
+ IntentB
+ IntentC
類型：Double  
有效範圍：最小值為 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 Lex 為語音設定的地區設定必須符合機器人的地區設定。如需詳細資訊，請參閱《[Amazon Polly 開發人員指南》中的 Amazon Polly 中的語音](https://docs.aws.amazon.com/polly/latest/dg/voicelist.html)。 *Amazon Polly *  
類型：字串  
必要：否

## 回應語法
<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 Model Building Service 建立的每個 Amazon Lex 機器人，您必須指定您對 Amazon Lex 的使用是否與網站、程式或其他應用程式相關，而該網站、程式或其他應用程式全部或部分針對 13 以下兒童，並在 `false` `childDirected` 欄位中指定 `true` 或 以遵守兒童線上隱私權保護法 (COPPA)。透過`true`在 `childDirected` 欄位中指定 ，您確認 Amazon Lex 的使用**與**網站、程式或其他應用程式相關，而該網站、程式或其他應用程式是全部或部分針對或鎖定 13 以下兒童，且受 COPPA 約束。透過`false`在 `childDirected` 欄位中指定 ，您確認 Amazon Lex 的使用與網站、程式或其他應用程式**無關**，該網站、程式或其他應用程式全部或部分針對 13 以下兒童，並受 COPPA 約束。您無法為 `childDirected` 欄位指定預設值，該值無法準確反映您對 Amazon Lex 的使用是否與網站、程式或其他應用程式相關，而該網站、程式或其他應用程式是針對或部分針對未滿 13 歲且受 COPPA 規範的 13 歲兒童。  
如果您使用 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>
機器人建立的日期。  
類型：Timestamp

 ** [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>
機器人更新的日期。當您建立資源時，建立日期和上次更新日期相同。  
類型：Timestamp

 ** [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>
在 [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) 回應中傳回替代意圖時`AMAZON.KendraSearchIntent`，決定 Amazon Lex 插入 `AMAZON.FallbackIntent`、 或兩者位置的分數。如果所有意圖的可信度分數都低於此值，`AMAZON.FallbackIntent`則會插入 。只有在為機器人設定時，`AMAZON.KendraSearchIntent`才會插入 。  
類型：Double  
有效範圍：最小值為 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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/PutBot) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/PutBot) 
+  [AWS 適用於 Java V2 的 SDK](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/PutBot) 
+  [AWS 適用於 JavaScript V3 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/PutBot) 
+  [AWS 適用於 Python 的 SDK](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>
建立機器人別名的日期。  
類型：Timestamp

 ** [description](#API_PutBotAlias_ResponseSyntax) **   <a name="lex-PutBotAlias-response-description"></a>
別名的描述。  
類型：字串  
長度限制：長度下限為 0。長度上限為 200。

 ** [lastUpdatedDate](#API_PutBotAlias_ResponseSyntax) **   <a name="lex-PutBotAlias-response-lastUpdatedDate"></a>
機器人別名的更新日期。當您建立資源時，建立日期和上次更新的日期相同。  
類型：Timestamp

 ** [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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/PutBotAlias) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/PutBotAlias) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/PutBotAlias) 
+  [AWS 適用於 Python 的 SDK](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 函數。如果您將意圖設定為將意圖資訊傳回至用戶端應用程式。

您可以在請求中指定其他選用資訊，例如：
+ 要求使用者確認意圖的確認提示。例如，「Shall I order your pizza？」
+ 滿足意圖後傳送給使用者的結論陳述式。例如，「我下了您的比薩訂單。」
+ 後續提示，要求使用者進行其他活動。例如，詢問「您想要搭配比薩訂購飲料嗎？」

如果您指定現有的意圖名稱來更新意圖，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 函數成功履行意圖之後，將 陳述式傳達給使用者。  
只有在您在 中提供 Lambda 函數時，此元素才相關`fulfillmentActivity`。如果您將意圖傳回用戶端應用程式，則無法指定此元素。  
`followUpPrompt` 和 `conclusionStatement`是互斥的。您只能指定一個。
類型：[Statement](API_Statement.md) 物件  
必要：否

 ** [confirmationPrompt](#API_PutIntent_RequestSyntax) **   <a name="lex-PutIntent-request-confirmationPrompt"></a>
提示使用者確認意圖。這個問題應該有「是」或「否」的答案。  
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 Kendra 索引的`AMAZON.KendraSearchIntent`意圖所需的組態資訊。如需詳細資訊，請參閱 [ AMAZON.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 比薩」、「Order \$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>
建立意圖的日期。  
類型：Timestamp

 ** [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>
意圖更新的日期。當您建立資源時，建立日期和上次更新日期相同。  
類型：Timestamp

 ** [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>
如果使用者對 Amazon Lex `confirmationPrompt` 中定義的問題回答「否」，則使用此陳述式回應，以確認意圖已取消。  
類型：[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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/PutIntent) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/PutIntent) 
+  [AWS 適用於 Java V2 的 SDK](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/PutIntent) 
+  [AWS 適用於 JavaScript V3 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/PutIntent) 
+  [AWS 適用於 Python 的 SDK](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>
槽類型的建立日期。  
類型：Timestamp

 ** [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>
槽類型更新的日期。當您建立槽類型時，建立日期和上次更新日期相同。  
類型：Timestamp

 ** [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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/PutSlotType) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/PutSlotType) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/PutSlotType) 
+  [AWS 適用於 Python 的 SDK](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>
請求匯入任務的日期和時間的時間戳記。  
類型：Timestamp

 ** [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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/StartImport) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/StartImport) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/StartImport) 
+  [AWS 適用於 Python 的 SDK](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 機器人名稱。 Amazon Lex V2  
類型：字串  
長度限制：長度下限為 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 V2 機器人的 Amazon Lex V1 機器人名稱。  
+ 如果 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>
遷移開始的日期和時間。  
類型：Timestamp

 ** [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 機器人名稱。 Amazon Lex V2  
類型：字串  
長度限制：長度下限為 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 使用者或角色無權呼叫遷移機器人所需的 Amazon Lex V2 APIs。  
HTTP 狀態碼：403

 ** BadRequestException **   
請求格式不正確。例如，值無效或缺少必要欄位。請檢查欄位值，然後再試一次。  
HTTP 狀態碼：400

 ** InternalFailureException **   
發生內部 Amazon Lex 錯誤。請再次嘗試您的請求。  
HTTP 狀態碼：500

 ** LimitExceededException **   
請求超過限制。請再次嘗試您的請求。  
HTTP 狀態碼：429

 ** NotFoundException **   
找不到請求中指定的資源。請檢查資源，然後再試一次。  
HTTP 狀態碼：404

## 另請參閱
<a name="API_StartMigration_SeeAlso"></a>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/StartMigration) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/StartMigration) 
+  [AWS 適用於 Java V2 的 SDK](https://docs.aws.amazon.com/goto/SdkForJavaV2/lex-models-2017-04-19/StartMigration) 
+  [AWS 適用於 JavaScript V3 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/StartMigration) 
+  [AWS 適用於 Python 的 SDK](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 Resource Name (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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/TagResource) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/TagResource) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/TagResource) 
+  [AWS 適用於 Python 的 SDK](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 Resource Name (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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/lex-models-2017-04-19/UntagResource) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/lex-models-2017-04-19/UntagResource) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/lex-models-2017-04-19/UntagResource) 
+  [AWS 適用於 Python 的 SDK](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 Runtime Service 支援下列動作：
+  [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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/runtime.lex-2016-11-28/DeleteSession) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/runtime.lex-2016-11-28/DeleteSession) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/runtime.lex-2016-11-28/DeleteSession) 
+  [AWS 適用於 Python 的 SDK](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`、 或 `PutSession`操作時`PostText`，可以設定內容。  
您可以使用內容來控制可追蹤意圖的意圖，或修改應用程式的操作。  
類型：[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>
代表工作階段特定內容資訊的鍵/值對映射。它包含 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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/runtime.lex-2016-11-28/GetSession) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/runtime.lex-2016-11-28/GetSession) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/runtime.lex-2016-11-28/GetSession) 
+  [AWS 適用於 Python 的 SDK](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 標頭。  
 Amazon Lex 在回應中傳回的訊息可以根據請求中的 `Accept` HTTP 標頭值為文字或語音。  
+  如果值為 `text/plain; charset=utf-8`，Amazon Lex 會在回應中傳回文字。
+  如果值以 開頭`audio/`，Amazon Lex 會在回應中傳回語音。Amazon Lex 使用 Amazon Polly 產生語音 （使用您在 `Accept`標頭中指定的組態）。例如，如果您指定 `audio/mpeg`做為值，Amazon Lex 會以 MPEG 格式傳回語音。
+ 如果值為 `audio/pcm`，則傳回的語音`audio/pcm`為 16 位元、小端數格式。
+ 以下是可接受的值：
  + 音訊/mpeg
  + 音訊/霧
  + 音訊/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 格式的音訊資料必須按小端位元組順序排列。
  + 音訊/l16；速率 = 16000；頻道 = 1
  + audio/x-l16； sample-rate=16000； channel-count=1
  + audio/lpcm； sample-rate=8000； sample-size-bits=16； channel-count=1； is-big-endian=false 
+ Opus 格式
  + audio/x-cbr-opus-with-preamble；preamble-size=0；位元速率=256000；frame-size-milliseconds=4
+ 文字格式
  + 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`、 或 `PutSession`操作時`PostText`，可以設定內容。  
您可以使用內容來控制可追蹤意圖的意圖，或修改應用程式的操作。

 ** [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 在回應中傳送此訊息：「您想要什麼大小的比薩？」。使用者可能會以槽值 （例如 "medium") 回覆。使用者也可能在回應中提供其他資訊 （例如，「中厚餅皮比薩」)。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 函數在其回應`dialogAction.type`中傳回`Delegate`為 ，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` 欄位為 null。您應該改用 `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` 欄位為 null。您應該改用 `encodedMessage` 欄位。  
要傳達給使用者的訊息。訊息可能來自機器人的組態或 Lambda 函數。  
如果意圖未使用 Lambda 函數設定，或者 Lambda 函數在其回應`dialogAction.type`中傳回`Delegate`為 ，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>
 代表工作階段特定內容資訊的鍵/值對映射。

 ** [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，則會傳回解析清單中的第一個值，或者如果沒有解析清單，則為 null。如果您未指定 `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 **   
Content-Type 標頭 (`PostContent` API) 的值無效。  
HTTP 狀態碼：415

## 範例
<a name="API_runtime_PostContent_Examples"></a>

### 範例 1
<a name="API_runtime_PostContent_Example_1"></a>

 在此請求中，URI 會識別機器人 （流量）、機器人版本 (\$1LATEST) 和最終使用者名稱 （使用者）。`Content-Type` 標頭可識別內文中音訊的格式。Amazon Lex 也支援其他格式。若要將音訊從一種格式轉換為另一種格式，如有必要，您可以使用 SoX 開放原始碼軟體。您可以透過新增 `Accept` HTTP 標頭來指定要取得回應的格式。

 在回應中， `x-amz-lex-message`標頭會顯示 Amazon Lex 傳回的回應。然後，用戶端可以將此回應傳送給使用者。相同的訊息會透過區塊編碼 （依要求） 以音訊/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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/runtime.lex-2016-11-28/PostContent) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/runtime.lex-2016-11-28/PostContent) 
+  [AWS 適用於 Java V2 的 SDK](https://docs.aws.amazon.com/goto/SdkForJavaV2/runtime.lex-2016-11-28/PostContent) 
+  [AWS 適用於 JavaScript V3 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/runtime.lex-2016-11-28/PostContent) 
+  [AWS 適用於 Python 的 SDK](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`、`intentName`、 `dialogState`和 `slots` 欄位。請考量下列範例：
+ 如果訊息是要引出槽資料，Amazon Lex 會傳回下列內容資訊：
  +  `dialogState` 設定為 ElicitSlot 
  +  `intentName` 設定為目前內容中的意圖名稱 
  +  `slotToElicit` 設定為 `message` 為其引出資訊的槽名稱 
  +  `slots` 設定為針對意圖設定的插槽映射，具有目前已知值 
+  如果訊息是確認提示，`dialogState`則 設定為 ConfirmIntent，而 `SlotToElicit` 設定為 null。
+ 如果訊息是釐清提示 （針對意圖設定），指出不了解使用者意圖，`dialogState`則 會設定為 ElicitIntent，並將 `slotToElicit` 設定為 null。

 此外，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`、 或 `PutSession`操作時`PostText`，可以設定內容。  
您可以使用內容來控制可追蹤意圖的意圖，或修改應用程式的操作。  
類型：[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 無法從此表達式推斷使用者意圖，則會傳回此 dialogState。
+  `ConfirmIntent` - Amazon Lex 預期收到「是」或「否」回應。

   例如，Amazon Lex 想要在滿足意圖之前確認使用者。

  使用者可能會回應其他資訊，而不是簡單的「是」或「否」。例如，「是的，但將其製作成厚皮比薩」或「否，我想要訂購飲料」。Amazon Lex 可以處理這類額外資訊 （在這些範例中，更新結構類型槽值，或將意圖從 OrderPizza 變更為 OrderDrink)。
+  `ElicitSlot` - Amazon Lex 預期目前意圖的槽值。

  例如，假設 Amazon Lex 在回應中傳送此訊息：「您想要什麼大小的比薩？」。使用者可能會以槽值 （例如 "medium") 回覆。使用者也可能在回應中提供其他資訊 （例如，「中厚餅皮比薩」)。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，則會傳回解析清單中的第一個值，或者如果沒有解析清單，則為 null。如果您未指定 `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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/runtime.lex-2016-11-28/PostText) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/runtime.lex-2016-11-28/PostText) 
+  [AWS 適用於 Java V2 的 SDK](https://docs.aws.amazon.com/goto/SdkForJavaV2/runtime.lex-2016-11-28/PostText) 
+  [AWS 適用於 JavaScript V3 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/runtime.lex-2016-11-28/PostText) 
+  [AWS 適用於 Python 的 SDK](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`，則會`audio/pcm`以 16 位元、小端數格式傳回語音。
+ 以下是可接受的值：
  +  `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>
代表工作階段特定內容資訊的鍵/值對映射。它包含 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` 欄位為 null。您應該改用 `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>
代表工作階段特定內容資訊的鍵/值對映射。

 ** [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，則會傳回解析清單中的第一個值，或者如果沒有解析清單，則為 null。如果您未指定 `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>

如需在其中一種語言特定 AWS SDKs中使用此 API 的詳細資訊，請參閱下列內容：
+  [AWS 命令列界面 V2](https://docs.aws.amazon.com/goto/cli2/runtime.lex-2016-11-28/PutSession) 
+  [AWS 適用於 .NET V4 的 SDK](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 的 SDK v2](https://docs.aws.amazon.com/goto/SdkForGoV2/runtime.lex-2016-11-28/PutSession) 
+  [AWS 適用於 Java V2 的 SDK](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 V3 的 SDK](https://docs.aws.amazon.com/goto/SdkForPHPV3/runtime.lex-2016-11-28/PutSession) 
+  [AWS 適用於 Python 的 SDK](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)