

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

# Amazon Lex V2 봇 작업
<a name="building-bots"></a>

Amazon Lex V2 봇을 생성하여 사용자와 상호 작용하여 작업을 수행하는 데 필요한 정보를 끌어냅니다. 예를 들어 꽃다발을 주문하거나 호텔 객실을 예약하는 데 필요한 정보를 수집하는 봇을 만들 수 있습니다.

봇을 빌드하려면 다음 정보가 필요합니다.

1. 봇이 고객과 상호 작용하는 데 사용하는 언어. 언어를 하나 이상 선택할 수 있으며, 각 언어에는 독립적인 의도, 슬롯 및 슬롯 유형이 포함됩니다.

1. 봇이 사용자가 달성하도록 돕는 의도 또는 목표. 봇에는 꽃 주문, 호텔 및 렌터카 예약과 같은 의도가 하나 이상 포함될 수 있습니다. 의도를 시작하기 위해 사용자가 어떤 진술 또는 발화를 할지 결정해야 합니다.

1. 의도를 이행하기 위해 사용자로부터 수집해야 하는 정보 또는 슬롯. 예를 들어 사용자로부터 꽃 종류나 호텔 예약 시작일을 확인해야 할 수 있습니다. Amazon Lex V2가 사용자로부터 슬롯 값을 추출하는 데 사용하는 프롬프트를 하나 이상 정의해야 합니다.

1. 사용자에게 필요한 슬롯의 유형. 사용자가 주문할 수 있는 꽃 목록과 같은 사용자 지정 슬롯 유형을 생성해야 할 수도 있고, 예약 시작 날짜로 `AMAZON.Date` 슬롯 유형을 사용하는 등 내장 슬롯 유형을 사용할 수도 있습니다.

1. 의도 내부 및 의도 간 사용자 상호 작용 흐름. 의도가 간접적으로 호출된 후 사용자와 봇 간의 상호작용을 정의하도록 대화 흐름을 구성할 수 있습니다. Lambda 함수를 생성하여 의도를 검증하고 이행합니다.

**Topics**
+ [Amazon Lex V2의 대화 흐름 변경 사항](understanding-new-flows.md)
+ [Amazon Lex V2를 사용하여 봇을 생성하는 다양한 방법](create-bot.md)
+ [Amazon Lex V2 봇에 새 언어 추가](add-language.md)
+ [의도 추가](add-intents.md)
+ [슬롯 유형 추가](add-slot-types.md)
+ [콘솔을 사용한 봇 테스트](test-bot.md)

**참고**  
2022년 8월 17일, Amazon Lex V2는 사용자와의 대화를 관리하는 방식에 대한 변경 사항을 발표했습니다. 이번 변경을 통해 사용자가 대화를 통해 이동하는 경로를 더 효과적으로 제어할 수 있게 되었습니다. 자세한 내용은 [Amazon Lex V2의 대화 흐름 변경 사항](understanding-new-flows.md) 단원을 참조하세요. 2022년 8월 17일 이전에 생성된 봇은 대화 코드 후크 메시지, 값 설정, 다음 단계 구성, 조건 추가를 지원하지 않습니다.

# Amazon Lex V2의 대화 흐름 변경 사항
<a name="understanding-new-flows"></a>

2022년 8월 17일, Amazon Lex V2는 사용자와의 대화를 관리하는 방식에 대한 변경 사항을 발표했습니다. 이번 변경을 통해 사용자가 대화를 통해 이동하는 경로를 더 효과적으로 제어할 수 있게 되었습니다.

변경 전에 Amazon Lex V2는 의도의 우선순위에 따라 슬롯을 생성하여 대화를 관리했습니다. Lambda 함수에서 DialogAction을 사용하여 이 동작을 동적으로 수정하고 사용자 입력에 따라 대화 경로를 변경할 수 있습니다. 대화의 현재 상태를 추적하고 세션 상태에 따라 다음에 수행할 작업을 프로그래밍 방식으로 결정하면 이를 수행할 수 있습니다.

이번 변경으로 Lambda 함수를 사용하지 않고도 Amazon Lex V2 콘솔 또는 API를 사용하여 대화형 경로와 조건부 분기를 생성할 수 있습니다. Amazon Lex V2는 대화의 상태를 추적하고 봇이 생성될 때 정의된 조건에 따라 다음에 수행할 작업을 제어합니다. 이렇게 하면 봇을 설계하면서 복잡한 대화를 쉽게 만들 수 있습니다.

이러한 변경을 통해 고객과의 대화를 완벽하게 제어할 수 있습니다. 하지만 경로를 정의할 필요는 없습니다. 대화 경로를 지정하지 않는 경우 Amazon Lex V2는 의도의 슬롯 우선순위에 따라 기본 경로를 생성합니다. 계속해서 Lambda 함수를 사용하여 대화 경로를 동적으로 정의할 수 있습니다. 이러한 시나리오에서는 Lambda 함수에 구성된 세션 상태를 기반으로 대화가 재개됩니다.

이 업데이트는 다음을 제공합니다.
+ 복잡한 대화 흐름을 사용하여 봇을 만들 수 있는 새로운 콘솔 환경.
+ 봇을 만들기 위한 기존 API를 업데이트하여 새 대화 흐름을 지원합니다.
+ 의도 간접 호출 시 메시지를 보내기 위한 초기 응답.
+ 슬롯 유도, 대화 코드 후크로서의 Lambda 간접 호출 및 확인에 대한 새로운 응답.
+ 대화가 진행될 때마다 다음 단계를 지정할 수 있습니다.
+ 여러 대화 경로를 설계하기 위한 조건 평가.
+ 대화 중 언제든지 슬롯 값 및 세션 속성 설정.

구형 봇의 경우 다음을 참고하세요.
+ 2022년 8월 17일 이전에 생성된 봇은 계속해서 이전 메커니즘을 사용하여 대화 흐름을 관리합니다. 해당 날짜 이후에 생성된 봇은 새로운 방식의 대화 흐름 관리를 사용합니다.
+ 2022년 8월 17일 이후에 가져오기를 통해 생성된 새 봇은 새로운 대화 흐름 관리를 사용합니다. 기존 봇에 대한 가져오기는 기존 대화 관리 방식을 계속 사용합니다.
+ 2022년 8월 17일 이전에 생성된 봇에 대해 새로운 대화 흐름 관리를 활성화하려면 봇을 내보낸 다음 새 봇 이름을 사용하여 봇을 가져오세요. 가져오기에서 새로 만든 봇은 새 대화 흐름 관리를 사용합니다.

2022년 8월 17일 이후에 생성된 새 봇에 대해서는 다음 사항을 참고하세요.
+ Amazon Lex V2는 설계된 대로 정확하게 정의된 대화 흐름을 따라 원하는 환경을 제공합니다. 런타임 중에 기본 대화 경로를 사용하지 않으려면 모든 흐름 분기를 구성해야 합니다.
+ 단계를 완료하지 않으면 봇이 실패할 수 있으므로 코드 후크 이후의 대화 단계는 완전히 구성해야 합니다. 2022년 8월 17일 이전에 생성된 봇의 경우 코드 후크 이후 대화 단계가 자동으로 검증되지 않으므로 해당 봇을 검증하는 것이 좋습니다.

# Amazon Lex V2를 사용하여 봇을 생성하는 다양한 방법
<a name="create-bot"></a>

Amazon Lex V2를 사용하여 다음과 같은 방법으로 봇을 만들 수 있습니다.

1. Amazon Lex V2 콘솔을 사용하면 웹 사이트 인터페이스를 사용하여 봇을 만들 수 있습니다. 자세한 내용은 [Amazon Lex V2 콘솔을 사용하여 봇 생성](create-bot-console.md) 단원을 참조하세요.

1. 설명형 봇 빌더를 사용하면 Amazon Bedrock의 생성형 AI 기능을 사용하여 봇을 만들 수 있습니다. 자세한 내용은 [설명을 사용하여 설명형 봇 빌더로 Lex V2에서 봇 빌드](nld-bots.md) 단원을 참조하세요.

1. 봇 템플릿을 사용하여 일반적인 비즈니스 사용 사례와 일치하는 사전 구성된 봇을 만들 수 있습니다. 자세한 내용은 [템플릿을 사용하여 Amazon Lex V2 봇 생성](bot-templates.md) 단원을 참조하십시오.

1. [AWS SDK](https://aws.amazon.com/tools/#sdk)를 사용하여 API 작업을 사용하여 봇을 생성합니다.

1. Automated Chatbot Designer를 사용하면 에이전트와 고객 간의 기존 채팅 기록을 사용하여 봇을 만들 수 있습니다. 자세한 내용은 [Automated Chatbot Designer를 사용하여 Amazon Lex V2 봇 생성](designing.md) 단원을 참조하세요.

1. 기존 봇 정의를 가져옵니다. 자세한 내용은 [Lex V2에서 봇 가져오기](import.md) 단원을 참조하십시오.

1. CloudFormation를 사용하여 봇을 생성합니다. 자세한 내용은 [를 사용하여 Amazon Lex V2 리소스 생성 AWS CloudFormation](creating-resources-with-cloudformation.md) 단원을 참조하십시오.

**Topics**
+ [Amazon Lex V2 콘솔을 사용하여 봇 생성](create-bot-console.md)
+ [템플릿을 사용하여 Amazon Lex V2 봇 생성](bot-templates.md)
+ [Automated Chatbot Designer를 사용하여 Amazon Lex V2 봇 생성](designing.md)

# Amazon Lex V2 콘솔을 사용하여 봇 생성
<a name="create-bot-console"></a>

Amazon Lex V2 봇을 생성하여 사용자와 상호 작용하여 작업을 수행하는 데 필요한 정보를 끌어냅니다. 예를 들어 꽃을 주문하거나 호텔 객실을 예약하는 데 필요한 정보를 수집하는 봇을 만들 수 있습니다. AWS 콘솔을 사용하여 봇을 생성하려면 먼저 이름, 설명 및 몇 가지 기본 정보를 정의합니다.

1. AWS Management Console에 로그인하여 [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)에서 Amazon Lex 콘솔을 엽니다.

1. **봇 생성**을 선택합니다.

1. **생성 방법** 섹션에서 **트래디셔널** 및 **빈 봇을 생성합니다**를 차례로 선택합니다.

1. **봇 구성** 섹션에서 봇의 이름과 선택적 설명을 입력합니다.

1. **IAM 권한** 섹션에서 Amazon Lex AWS 서비스에 액세스할 수 있는 Amazon Lex V2 권한을 제공하는 AWS Identity and Access Management(IAM) 역할을 선택합니다. V2 Amazon CloudWatch Amazon Lex V2가 역할을 생성하도록 하거나 CloudWatch 권한이 있는 기존 역할을 선택할 수 있습니다.

1. **COPPA(Children's Online Privacy Protection Act, 어린이 온라인 사생활 보호법)** 섹션에서 적합한 응답을 선택합니다.

1. **유휴 세션 제한 시간** 섹션에서 Amazon Lex V2가 사용자와의 세션을 열어 두는 기간을 선택합니다. Amazon Lex V2는 봇이 동일한 변수로 대화를 재개할 수 있도록 세션 기간 동안 세션 변수를 유지 관리합니다.

1. **고급 설정**(옵션) 섹션에서 봇을 식별하고 액세스를 제어하거나 리소스를 모니터링하는 데 도움이 되는 태그를 추가합니다.

1. **다음**을 선택하여 봇을 만들고 언어 추가로 이동합니다.

# 템플릿을 사용하여 Amazon Lex V2 봇 생성
<a name="bot-templates"></a>

Amazon Lex V2는 대규모 환경을 구축하고 디지털 참여를 유도하기 위해 사전 빌드된 솔루션을 제공합니다. 사전 빌드된 봇 템플릿은 클라이언트 환경을 자동화하고 표준화합니다. 봇 템플릿은 음성 및 채팅 방식 모두에 대해 교육 데이터 및 대화 프롬프트와 함께 즉시 사용할 수 있는 대화 흐름을 제공합니다. 리소스를 최적화하면서 봇 솔루션 제공을 가속화하여 고객 관계에 집중할 수 있습니다.

비즈니스 사용 사례에 따라 사전 구축된 봇을 만들 수 있습니다. CloudFormation콘솔을 사용하여 Amazon S3, Amazon Connect 및 DynamoDB와 같은 관련 서비스에 대해 사전 구축된 옵션을 선택할 수 있습니다.

현재 Amazon Lex V2는 다음과 같은 비즈니스 분야를 지원합니다.
+ 금융 서비스
+ 소매 주문
+ 자동차 보험
+ 통신
+ 항공 서비스
+ 향후 추가 템플릿을 사용할 수 있습니다.

제공된 비즈니스 솔루션 템플릿으로 봇을 빌드하고 비즈니스 요구 사항에 맞게 사용자 지정할 수 있습니다.

**참고**  
템플릿은 CloudFormation 스택을 통해 Amazon Lex V2 외부의 리소스를 생성합니다. Lambda 및 DynamoDB와 같은 다른 콘솔에서 스택을 수정해야 할 수 있습니다.

**봇 템플릿을 구축하고 배포하기 위한 사전 요구 사항:**
+ AWS 계정
+ 다음 AWS 서비스에 대한 액세스:
  + 봇을 생성하기 위한 Amazon Lex V2
  + 비즈니스 로그인 함수를 위한 Lambda
  + 테이블을 생성하기 위한 DynamoDB
  + 정책 및 역할 생성을 위한 IAM 액세스
  + 스택을 실행하기 위한 AWS CloudFormation 
+ IAM 액세스 권한 및 비밀 키 보안 인증 정보
+ Amazon Connect 인스턴스(선택 사항)

**참고**  
서로 다른 AWS 서비스를 사용하면 각 서비스에 대해 각 사용 비용이 발생합니다.

**Amazon Lex V2 템플릿에서 봇을 구축하려면:**

1. AWS Management Console에 로그인하여 [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)에서 Amazon Lex 콘솔을 엽니다.

1. 왼쪽 탐색 창에서 **봇 템플릿**을 선택합니다.

1. 봇 템플릿에 사용할 비즈니스 카테고리를 선택합니다. 참고: 현재 사용할 수 있는 봇 템플릿은 5개입니다. 더 많은 템플릿을 제공할 예정입니다.

1. 사용할 템플릿에서 **만들기**를 선택합니다. CloudFormation스택의 파라미터를 편집할 수 CloudFormation있는 탭이에서 열립니다. 선택한 템플릿에 대한 모든 옵션이 이미 완성되었습니다. **자세히 알아보기**를 선택하여 봇 템플릿의 작동 방식에 대해 자세히 알아볼 수도 있습니다.

1. CloudFormation콘솔에서는 선택한 템플릿의 각 값에 대한 기본 구성을 CloudFormation생성합니다. 자체 스택 이름, CloudFormation파라미터, Amazon DynamoDB 테이블 및 (선택 사항) Amazon Connect 파라미터를 선택할 수도 있습니다.

1. 창 하단에서 **스택 생성**을 선택합니다.

1. CloudFormation는 백그라운드에서 몇 분 동안 요청을 처리하여 새 봇을 구성합니다. 참고: 이 프로세스는 DynamoDB 테이블, Amazon Connect 통화 흐름 및 Amazon Connect 인스턴스에 대한 리소스를 자동으로 생성합니다. CloudFormation콘솔에서 진행 상황을 추적한 다음 CloudFormation 스택 생성이 완료되면 Amazon Lex V2 콘솔로 다시 이동할 수 있습니다.

1. 성공적으로 구축되면 메시지가 표시되고 **봇 목록으로 이동**을 선택하여 **봇** 페이지로 이동하여 테스트 및 사용할 준비가 된 새 봇을 찾을 수 있습니다.

**봇 템플릿 구성**

**Lambda 함수** – 봇 템플릿은 배포에 필요한 Lambda 함수를 자동으로 생성합니다. 여러 봇이 템플릿 솔루션의 일부인 경우 여러 Lambda 함수가 CloudFormation 파라미터에 나열됩니다. 봇과 함께 배포할 기존 Lambda 함수가 있는 경우 사용자 지정 Lambda 함수의 이름을 입력할 수 있습니다.

**Amazon DynamoDB** – 봇 템플릿은 샘플 정책 데이터를 로드하는 데 필요한 DynamoDB 테이블을 자동으로 생성합니다. 사용자 지정 DynamoDB 테이블의 이름을 입력할 수도 있습니다. 사용자 지정 DynamoDB 테이블은 봇 템플릿 배포에서 생성한 기본 테이블과 같은 방식으로 형식을 지정해야 합니다.

**Amazon Connect** – ConnectInstanceARN과 고유한 ContactFlowName을 입력하여 새 봇 템플릿과 함께 작동하도록 Amazon Connect 인스턴스를 구성할 수 있습니다. Amazon Connect를 사용하면 IVR 시스템을 사용하여 봇을 처음부터 끝까지 테스트할 수 있습니다.

**봇 템플릿 문제 해결**
+ 선택한 템플릿을 만들 수 있는 적절한 권한이 있는지 확인하세요. 사용자는 템플릿 내에 나열된 AWS 리소스에 대한 권한과 함께 CloudFormation:CreateStack 권한이 필요합니다. 사용자 권한이 필요한 리소스 목록은 **템플릿 생성** 페이지 하단에 있습니다.
+ 봇 템플릿을 생성하지 못하면 Amazon Lex V2 콘솔 내의 빨간색 배너가 템플릿 생성을 담당하는 CloudFormation스택에 대한 링크를 제공합니다. CloudFormation콘솔 내에서 이벤트 탭을 보고 템플릿 실패의 원인이 된 특정 오류를 확인할 수 있습니다. CloudFormation 오류를 검토한 후 자세한 내용은 [CloudFormation 문제 해결](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/troubleshooting.html)을 참조하세요.
+ 봇 템플릿은 샘플 데이터에만 사용할 수 있습니다. 템플릿이 사용자 지정 데이터와 함께 작동하도록 하려면 DynamoDB 테이블을 데이터로 채워야 합니다.

# Automated Chatbot Designer를 사용하여 Amazon Lex V2 봇 생성
<a name="designing"></a>

Automated Chatbot Designer를 사용하면 기존 대화 기록을 바탕으로 봇을 설계할 수 있습니다. 대화 기록을 분석하고 의도와 슬롯 유형을 포함한 초기 설계를 제안합니다. 봇 설계를 반복하고, 프롬프트를 추가하고, 봇을 빌드, 테스트 및 배포할 수 있습니다.

Amazon Lex V2 콘솔 또는 API를 사용하여 새 봇을 만들거나 봇에 언어를 추가한 후, 양 당사자 간의 대화 기록을 업로드할 수 있습니다. 자동화된 챗봇 디자이너가 대화 기록을 분석하고 봇의 의도와 슬롯 유형을 결정합니다. 또한 검토를 위한 특정 의도 또는 슬롯 유형을 생성하는 데 영향을 미친 대화에 레이블을 지정합니다.

Amazon Lex V2 콘솔 또는 API를 사용하여 대화 기록을 분석하고 봇의 의도와 슬롯 유형을 제안합니다.

**참고**  
영어(미국) 언어로 된 대화 기록만 사용할 수 있습니다.

챗봇 디자이너가 분석을 완료한 후 추천 의도와 슬롯 유형을 검토할 수 있습니다. 추천 의도 또는 슬롯 유형을 추가한 후에는 콘솔 또는 API를 사용하여 이를 수정하거나 봇 디자인에서 삭제할 수 있습니다.

Automated Chatbot Designer는 Contact Lens for Amazon Connect 스키마를 사용하여 대화 기록 파일을 지원합니다. 다른 고객 센터 애플리케이션을 사용하는 경우 대화 기록을 챗봇 디자이너가 사용하는 형식으로 변환해야 합니다. 자세한 내용은 [입력 대화 기록 형식](designing-input-format.md) 단원을 참조하세요.

자동화된 챗봇 디자이너를 사용하려면 디자이너 액세스를 실행하는 IAM 역할을 허용해야 합니다. 구체적인 IAM 정책은 [사용자가 Automated Chatbot Designer를 사용할 수 있도록 허용](security_iam_id-based-policy-examples.md#security_iam-bot-designer)를 참조하세요. Amazon Lex V2가 선택적 AWS KMS 키로 출력 데이터를 암호화하도록 하려면에 표시된 정책으로 키를 업데이트해야 합니다[사용자가 AWS KMS 키를 사용하여 파일을 암호화 및 복호화하도록 허용](security_iam_id-based-policy-examples.md#security_iam-bot-key).

**참고**  
를 사용하는 경우 사용된 IAM 역할에 관계없이 **KMS key 정책을** 제공해야 KMS key합니다.

**Topics**
+ [대화 기록 가져오기](designing-import.md)
+ [의도 및 슬롯 유형 생성](designing-create.md)
+ [입력 대화 기록 형식](designing-input-format.md)
+ [출력 대화 기록 형식](designing-output-format.md)

# 대화 기록 가져오기
<a name="designing-import"></a>

다음 3단계 프로세스를 통해 대화 기록을 가져옵니다.

1. 대화 기록을 올바른 형식으로 변환하여 가져올 준비를 합니다. Contact Lens for Amazon Connect를 사용하는 경우 대화 기록은 이미 올바른 형식으로 되어 있습니다.

1. Amazon S3 버킷에 대화 기록을 업로드합니다. Contact Lens를 사용하는 경우, 대화 기록은 이미 S3 버킷에 있습니다.

1. Amazon Lex V2에 사용되는 콘솔 또는 API 작업을 사용하여 대화 기록을 분석합니다. 교육을 완료하는 데 걸리는 시간은 대화 기록의 양과 대화의 복잡성에 따라 달라집니다. 일반적으로 1분마다 500줄의 대화 기록이 분석됩니다.

다음 섹션에서는 이러한 각 단계에 대해 설명합니다.

## Contact Lens for Amazon Connect에서 대화 기록 가져오기
<a name="import-connect"></a>

Amazon Lex V2 Automated Chatbot Designer는 Contact Lens 대화 기록 파일과 호환됩니다. Contact Lens 대화 기록 파일을 사용하려면 Contact Lens를 켜고 출력 파일의 위치를 기록해 두어야 합니다.

**Contact Lens에서 대화 기록을 내보내는 방법**

1. Amazon Connect 인스턴스에서 Contact Lens를 켜세요. 지침은 **Amazon Connect 관리자 안내서에서 [Enable Contact Lens for Amazon Connect](https://docs.aws.amazon.com/connect/latest/adminguide/enable-analytics.html)를 참조하세요.

1. Amazon Connect가 인스턴스에 사용하는 S3 버킷의 위치를 기록해 둡니다. 위치를 보려면 Amazon Connect 콘솔에서 **데이터 스토리지** 페이지를 여세요. 지침은 *Amazon Connect 관리자 안내서*의 [인스턴스 설정 업데이트](https://docs.aws.amazon.com/connect/latest/adminguide/update-instance-settings.html)를 참조하세요.

Contact Lens를 켜고 대화 기록 파일의 위치를 확인한 후, [Amazon Lex V2에서 대화 기록을 분석합니다.](#import-import)으로 이동하여 대화 기록 가져오기 및 분석 지침을 확인하세요.

## 대화 기록 준비
<a name="import-prepare"></a>

대화 기록 파일을 만들어 대화 기록을 준비하세요.
+ 대화별로 대화 당사자 간의 상호 작용을 나열하는 기록 파일을 하나씩 만드세요. 대화의 각 상호 작용은 여러 줄에 걸쳐 이루어질 수 있습니다. 대화의 수정된 버전과 수정되지 않은 버전을 모두 제공할 수 있습니다.
+ 파일은 [입력 대화 기록 형식](designing-input-format.md)에 지정된 JSON 형식이어야 합니다.
+ 최소 1,000회의 대화형 턴을 제공해야 합니다. 의도와 슬롯 유형을 더 잘 검색하려면 약 10,000개 이상의 대화형 턴을 제공해야 합니다. 자동화된 챗봇 디자이너는 처음 700,000번의 턴만 처리합니다.
+ 업로드할 수 있는 대화 기록 파일 수에는 제한이 없으며 파일 크기 제한도 없습니다.

가져온 대화 기록을 날짜별로 필터링하려는 경우 파일은 다음과 같은 디렉터리 구조에 있어야 합니다.

```
<path or bucket root>
   --> yyyy
      --> mm
         --> dd
            --> transcript files
```

 대화 기록 파일의 파일 이름 어딘가에 “yyyy-mm-dd” 형식의 날짜가 포함되어야 합니다.

**다른 고객 센터 애플리케이션에서 대화 기록을 내보내는 방법**

1. 고객 센터 애플리케이션의 도구를 사용하여 대화를 내보낼 수 있습니다. 대화에는 최소한 [입력 대화 기록 형식](designing-input-format.md)에 지정된 정보가 포함되어야 합니다.

1. 고객 센터 애플리케이션에서 만든 대화 기록을 [입력 대화 기록 형식](designing-input-format.md)에 설명된 형식으로 변환하세요. 변환을 수행할 책임은 사용자에게 있습니다.

대화 기록 준비를 위한 세 가지 스크립트를 제공합니다. 스크립트는 다음과 같습니다.
+ Contact Lens 대화 기록을 Amazon Lex V2 대화 로그와 결합하는 스크립트. Contact Lens 대화 기록에는 Amazon Lex V2 봇과 상호 작용하는 Amazon Connect 대화 부분이 포함되지 않습니다. 스크립트에는 Amazon Lex V2용 대화 로그가 켜져 있어야 하고 대화 로그 CloudWatch Logs 및 Contact Lens S3 버킷을 쿼리할 수 있는 적절한 권한이 필요합니다.
+ Amazon Transcribe Call Analytics를 Amazon Lex V2 입력 형식으로 변환하는 스크립트.
+ Amazon Connect 채팅 기록을 Amazon Lex V2 입력 형식으로 변환하는 스크립트.

다음 GitHub 리포지토리 [ https://github.com/aws-samples/amazon-lex-bot-recommendation-integration ](https://github.com/aws-samples/amazon-lex-bot-recommendation-integration)에서 스크립트를 다운로드할 수 있습니다.

## S3 버킷에 대화 기록 업로드
<a name="import-upload"></a>

Contact Lens를 사용하는 경우, 대화 기록 파일은 이미 S3 버킷에 포함되어 있습니다. 대화 기록 파일의 위치 및 파일 이름은 *Amazon Connect 관리자 안내서*의 [Contact Lens 출력 파일 예시](https://docs.aws.amazon.com/connect/latest/adminguide/contact-lens-example-output-files.html)를 참조하세요.

다른 고객 센터 애플리케이션을 사용하고 있고 대화 기록 파일에 S3 버킷을 설정하지 않은 경우, 이 절차를 따르세요. 그렇지 않고, 기존 S3 버킷이 있는 경우 Amazon S3 콘솔에 로그인한 후 5단계부터 이 절차를 따르세요.

**S3 버킷에 파일을 업로드하려면**

1. AWS Management Console에 로그인하고 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)에서 Amazon S3 콘솔을 엽니다.

1. **버킷 생성**을 선택합니다.

1. 버킷에 이름을 지정하고 리전을 선택합니다. 이 리전은 Amazon Lex V2에 사용하는 리전과 동일해야 합니다. 사용 사례에 맞게 다른 옵션을 설정합니다.

1. **버킷 생성**을 선택합니다.

1. 버킷 목록에서 기존 버킷 또는 방금 만든 버킷을 선택합니다.

1. **업로드**를 선택합니다.

1. 업로드하려는 대화 기록 파일을 추가합니다.

1. **업로드**를 선택합니다.

## Amazon Lex V2에서 대화 기록을 분석합니다.
<a name="import-import"></a>

자동 봇 디자인은 빈 언어로만 사용할 수 있습니다. 기존 봇에 새 언어를 추가하거나 새 봇을 생성할 수 있습니다.

**새 봇에서 새 언어를 생성하는 방법**

1. AWS Management Console에 로그인하여 [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)에서 Amazon Lex 콘솔을 엽니다.

1. **봇 생성**을 선택합니다.

1. **Automated Chatbot Designer로 시작**을 선택합니다. 정보를 입력하여 새 봇을 만듭니다.

1. **다음**을 선택합니다.

1. **봇에 언어 추가**에서 해당 언어에 대한 정보를 입력합니다.

1. 필요한 경우 **S3의 대화 기록 파일 위치** 섹션에서 대화 기록 파일이 들어 있는 S3 버킷과 파일의 로컬 경로를 선택합니다.

1. 옵션으로 다음을 선택할 수 있습니다.
   + 처리 중에 트랜스크립트 데이터를 암호화하는 AWS KMS 키입니다. 키를 선택하지 않으면 서비스 AWS KMS 키가 사용됩니다.
   + 대화 기록을 특정 날짜 범위로 필터링하는 방법. 대화 기록을 필터링하기로 선택한 경우 대화 기록이 올바른 폴더 구조에 있어야 합니다. 자세한 내용은 [대화 기록 준비](#import-prepare) 단원을 참조하세요.

1. **완료**를 선택합니다.

Amazon Lex V2에서 대화 기록을 처리할 때까지 기다립니다. 분석이 완료되면 완료 메시지가 표시됩니다.

**대화 기록 분석을 중단하는 방법**

업로드한 대화 기록의 분석을 중지해야 하는 경우, 처리 중 상태가 `BotRecommendationStatus`로 설정되어 있는 진행 중인 `BotRecommendation` 작업을 중지할 수 있습니다. 콘솔에서 작업을 제출한 후 또는`StopBotRecommendation` API용 CLI SDK를 사용하여 배너에 있는 **처리 중지** 버튼을 클릭할 수 있습니다. 자세한 내용은 [StopBotRecommendation](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_StopBotRecommendation.html)을 참조하세요.

`StopBotRecommendation`를 직접적으로 호출하면 내부 `BotRecommendationStatus`가 `Stopping`로 설정되고 요금이 청구되지 않습니다. 작업이 중지되었는지 확인하려면 `DescribeBotRecommendation` API를 직접적으로 호출하여 `BotRecommendationStatus`가 `Stopped`인지 확인하면 됩니다. 보통 3\$14분이 소요됩니다.

`StopBotRecommendation` API가 직접적으로 호출된 후에는 처리 비용이 청구되지 않습니다.

# 의도 및 슬롯 유형 생성
<a name="designing-create"></a>

챗봇 디자이너가 의도와 슬롯 유형을 생성한 후 봇에 추가할 의도와 슬롯 유형을 선택합니다. 각 의도 및 슬롯 유형의 세부 정보를 검토하여 사용 사례에 가장 적합한 권장 사항을 결정할 수 있습니다.

추천 의도의 이름을 클릭하면 챗봇 디자이너가 제안한 샘플 발언 및 슬롯을 볼 수 있습니다. **관련 대화 기록 보기**를 선택하면 제공한 대화를 스크롤할 수도 있습니다. 이러한 대화 기록은 챗봇 디자이너가 이 의도를 추천하는 데 영향을 줍니다. 샘플 발언을 클릭하면 해당 특정 발언에 영향을 준 주요 대화와 관련 대화 순서를 검토할 수 있습니다.

특정 슬롯 유형의 이름을 클릭하여 추천 슬롯 값을 볼 수 있습니다. **관련 대화 기록 보기**를 선택하면 슬롯 유형을 유도하는 에이전트 프롬프트가 강조 표시되어 이 슬롯 유형에 영향을 미친 대화를 검토할 수 있습니다. 특정 슬롯 유형 값을 클릭하면 기본 대화와 이 값에 영향을 미친 관련 대화 턴을 검토할 수 있습니다.

**의도와 슬롯 유형을 검토하고 추가하는 방법**

1. AWS Management Console에 로그인하여 [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)에서 Amazon Lex 콘솔을 엽니다.

1. 봇 목록에서 작업하려는 봇을 선택합니다.

1. **언어 보기**를 선택합니다.

1. 언어 목록에서 사용할 언어를 선택합니다.

1. **대화 구조**에서 **검토**를 선택합니다.

1. 의도 및 슬롯 유형 목록에서 봇에 추가할 의도와 슬롯 유형을 선택합니다. 의도 또는 슬롯 유형을 선택하여 세부 정보 및 관련 스크립트를 볼 수 있습니다.

의도는 Amazon Lex V2가 처리된 대화 기록과 의도가 연관되어 있다고 확신하는 정도에 따라 정렬됩니다.

# 입력 대화 기록 형식
<a name="designing-input-format"></a>

다음은 봇의 의도와 슬롯 유형을 생성하기 위한 입력 파일 형식입니다. 입력 파일에는 이러한 필드가 포함되어야 합니다. 다른 필드는 무시됩니다.

입력 형식은 Contact Lens for Amazon Connect의 출력 형식과 호환됩니다. Contact Lens를 사용하는 경우 스크립트 파일을 수정할 필요가 없습니다. 자세한 내용은 [Contact Lens 출력 파일 예시](https://docs.aws.amazon.com/connect/latest/adminguide/contact-lens-example-output-files.html)를 참조하세요. 다른 고객 센터 애플리케이션을 사용하는 경우, 대화 기록 파일을 이 형식으로 변환해야 합니다.

```
{
    "Participants": [
        {
            "ParticipantId": "string",
            "ParticipantRole": "AGENT | CUSTOMER"
        }
    ],
    "Version": "1.1.0",
    "ContentMetadata": {
        "RedactionTypes": [
            "PII"
        ],
        "Output": "Raw | Redacted"
    },
    "CustomerMetadata": {
        "ContactId": "string"
    },
    "Transcript": [
        {
            "ParticipantId": "string",
            "Id": "string",
            "Content": "string"
        }
    ]
}
```

입력 파일에 다음 필드가 있어야 합니다.
+ **Participants**   대화 참가자와 이들이 수행하는 역할을 표시합니다.
+ **Version**   입력 파일 형식의 버전입니다. 항상 “1.1.0”입니다.
+ **ContentMetadata**   대화 기록에서 민감한 정보를 삭제했는지 여부를 나타냅니다. 대화 기록에 민감한 정보가 포함되어 있는 경우 `Output` 필드를 “Raw”로 설정하세요.
+ **CustomerMetadata**   대화의 고유 식별자입니다.
+ **Transcript**  대화에 참여한 당사자 간의 대화 텍스트입니다. 대화의 각 턴은 고유한 식별자로 식별됩니다.

# 출력 대화 기록 형식
<a name="designing-output-format"></a>

출력 대화 기록 형식은 입력 대화 기록 형식과 거의 같습니다. 하지만 여기에는 일부 고객 메타데이터와 의도 및 슬롯 유형 제안에 영향을 미친 세그먼트를 나열하는 필드도 포함됩니다. 콘솔의 **검토** 페이지에서 또는 Amazon Lex V2 API를 사용하여 출력 대화 기록을 다운로드할 수 있습니다. 자세한 내용은 [입력 대화 기록 형식](designing-input-format.md) 단원을 참조하세요.

```
{
    "Participants": [
        {
            "ParticipantId": "string",
            "ParticipantRole": "AGENT | CUSTOMER"
        }
    ],
    "Version": "1.1.0",
    "ContentMetadata": {
 
        "RedactionTypes": [
            "PII"
        ],
        "Output": "Raw | Redacted"
    },
    "CustomerMetadata": {
        "ContactId": "string",
        "FileName": "string",
        "InputFormat": "Lex"
    },
    "InfluencingSegments": [
        {
            "Id": "string",
            "StartTurnIndex": number,
            "EndTurnIndex": number,
            "Intents": [
                {
                    "Id": "string",
                    "Name": "string",
                    "SampleUtteranceIndex": [
                        {
                            "Index": number,
                            "Content": "String"
                        }
                    ]
                }
            ],
            "SlotTypes": [
                {
                    "Id": "string",
                    "Name": "string",
                    "SlotValueIndex": [
                        {
                            "Index": number,
                            "Content": "String"
                        }
                    ]
                }
            ]
        }
    ],
    "Transcript": [
        {
 
            "ParticipantId": "string",
            "Id": "string",
            "Content": "string"
        }
    ]
}
```
+ **CustomerMetadata** — `CustomerMetadata` 필드에 두 개의 필드, 즉 대화가 포함된 입력 파일의 이름과 입력 형식(항상 “Lex”)이 추가됩니다.
+ **InfluencingSegments** – 의도 또는 슬롯 유형의 제안에 영향을 미친 대화의 세그먼트를 표시합니다. 의도 또는 슬롯 유형의 ID는 대화의 영향을 받은 특정 의도를 표시합니다.

# Amazon Lex V2 봇에 새 언어 추가
<a name="add-language"></a>

봇이 해당 언어로 사용자와 소통할 수 있도록 봇에 하나 이상의 언어와 로캘을 추가합니다. 발화, 프롬프트 및 슬롯 값이 언어별로 고유하도록 각 언어에 대해 의도, 슬롯 및 슬롯 유형을 개별적으로 정의합니다.

봇에 하나 이상의 언어가 들어 있어야 합니다.

**봇에 언어를 추가하려면**

1. AWS Management Console에 로그인하여 [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)에서 Amazon Lex 콘솔을 엽니다.

1. **봇** 섹션에서 언어를 추가할 봇을 선택합니다.

1. **언어 추가** 섹션에서 **언어 보기**를 클릭합니다.

1. **모든 언어** 섹션에서 **언어 추가**를 클릭합니다.

1. **새 언어 추가** 섹션에서 **언어 새로 추가**를 선택합니다.

1. **언어 세부 정보** 섹션에서 사용하려는 언어를 선택합니다.

1. 봇이 음성 상호 작용을 지원하는 경우 **음성** 섹션에서 Amazon Lex V2가 사용자와 통신하는 데 사용하는 Amazon Polly 음성을 선택합니다. 봇이 음성을 지원하지 않는 경우 **없음**을 선택합니다.

1. **의도 분류 신뢰도 점수 임곗값** 섹션에서 Amazon Lex V2가 의도가 올바른 의도인지 판단하는 데 사용하는 값을 설정합니다. 봇을 테스트한 후 이 값을 조정할 수 있습니다.

1. **추가**를 선택합니다.

# 의도 추가
<a name="add-intents"></a>

의도는 꽃을 주문하거나 호텔을 예약하는 등 사용자가 달성하고자 하는 목표입니다. 봇에는 의도가 하나 이상 있어야 합니다.

기본적으로 모든 봇에는 폴백 의도라는 단일 기본 제공 의도가 포함되어 있습니다. 이 의도는 Amazon Lex V2가 다른 의도를 인식하지 못할 때 사용됩니다. 예를 들어 사용자가 호텔 예약 의도에 “꽃을 주문하고 싶어요”라고 말하면 폴백 의도가 트리거됩니다.

**의도를 추가하려면**

1. AWS Management Console에 로그인하여 [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)에서 Amazon Lex 콘솔을 엽니다.

1. 봇 목록에서 의도를 추가할 봇을 선택한 다음 **언어 추가**에서 **언어 보기**를 선택합니다.

1. 의도를 추가할 언어를 선택한 다음 **의도**를 선택합니다.

1. **의도 추가**를 선택하고 의도에 이름을 지정한 다음 **추가**를 선택합니다.

1. 의도 편집기에서 의도의 세부 정보를 추가합니다.
   + **대화 흐름** – 대화 흐름도를 사용하여 봇과의 대화가 어떻게 보일지 확인해 보세요. 대화의 여러 섹션을 선택하여 의도 편집기의 해당 섹션으로 이동할 수 있습니다.
   + **의도 세부 정보** - 의도의 목적을 식별하는 데 도움이 되도록 의도에 이름과 설명을 입력합니다. Amazon Lex V2가 의도에 할당한 고유 식별자도 확인할 수 있습니다.
   + **컨텍스트** – 의도의 입력 및 출력 컨텍스트를 설정합니다. 컨텍스트는 의도와 관련된 상태 변수입니다. 의도가 이행되면 출력 컨텍스트가 설정됩니다. 입력 컨텍스트가 있는 의도는 컨텍스트가 활성화된 경우에만 인식할 수 있습니다. 입력 컨텍스트가 없는 의도는 항상 인식할 수 있습니다.
   + **샘플 발화** – 사용자가 의도를 시작할 때 사용할 것으로 예상되는 문구를 10개 이상 입력해야 합니다. Amazon Lex V2는 이러한 문구를 일반화하여 사용자가 의도를 시작하기를 원한다는 것을 인식합니다.
   + **초기 응답** – 의도가 간접적으로 호출된 후 사용자에게 전송되는 초기 메시지입니다. 응답을 제공하고, 값을 초기화하고, Amazon Lex V2가 의도를 시작할 때 사용자에게 응답하기 위해 취하는 다음 단계를 정의할 수 있습니다.
   + **슬롯** – 의도를 이행하는 데 필요한 슬롯 또는 파라미터를 정의합니다. 각 슬롯에는 슬롯에 입력할 수 있는 값을 정의하는 유형이 있습니다. 사용자 지정 슬롯 유형 중에서 선택하거나 내장 슬롯 유형을 선택할 수 있습니다.
   + **확인** – 이러한 메시지와 응답은 의도의 이행을 확인하거나 거부하는 데 사용됩니다. 확인 프롬프트는 사용자에게 슬롯 값을 검토하도록 요청합니다. 예: “금요일에 호텔 객실을 예약했습니다. 맞나요?” 거절 응답은 사용자가 확인을 거부하면 사용자에게 전송됩니다. 응답을 제공하고, 값을 설정하고, 사용자의 확인 또는 거부 응답에 따라 Amazon Lex V2가 수행하는 다음 단계를 정의할 수 있습니다.
   + **이행** – 이행 과정에서 사용자에게 전송되는 응답입니다. 이행 시작 시 및 이행 진행 중 주기적으로 이행 진행 상황 업데이트를 설정할 수 있습니다. 예: “비밀번호를 변경하고 있습니다. 이 작업은 몇 분 정도 걸릴 수 있습니다.” 및 “아직 요청을 처리 중입니다.” 이행 업데이트는 스트리밍 대화에만 사용됩니다. 이행 후 성공 메시지, 실패 메시지 및 시간 초과 메시지를 설정할 수도 있습니다. 스트리밍 및 일반 대화 모두에 대해 이행 후 메시지를 보낼 수 있습니다. 예를 들어, 이행이 성공하면 “비밀번호를 변경했습니다.”를 보낼 수 있습니다. 이행이 실패하는 경우 “비밀번호를 변경할 수 없습니다. 지원 센터에 문의하여 지원을 요청하세요.”와 같은 추가 정보가 포함된 응답을 보낼 수 있습니다. 이행이 구성된 제한 시간보다 오래 걸리는 경우 사용자에게 “현재 서버가 매우 바쁩니다. 요청을 다시 시도하세요.”와 같은 메시지를 보낼 수 있습니다. 응답을 제공하고, 값을 설정하고, Amazon Lex V2가 사용자에게 응답하기 위해 취할 다음 단계를 정의할 수 있습니다.
   + **종료 응답** – 의도가 충족되고 다른 모든 메시지가 재생된 후 사용자에게 전송되는 응답입니다. 예를 들어, 호텔 객실을 예약해 주셔서 감사합니다. 또는 사용자에게 “방을 예약해 주셔서 감사합니다. 렌터카를 예약하시겠습니까?”와 같이 다른 의도를 시작하라는 메시지를 표시할 수도 있습니다. 의도를 충족하고 종료 응답으로 응답한 후 응답을 제공하고 후속 조치를 구성할 수 있습니다.
   + **코드 후크** – 의도를 초기화하고 사용자 입력을 검증하는 AWS Lambda 함수를 사용하고 있는지 여부를 나타냅니다. 봇을 실행하는 데 사용하는 별칭에 Lambda 함수를 지정합니다.

1. **의도 저장**을 선택하여 의도를 저장합니다.

**참고**  
2022년 8월 17일, Amazon Lex V2는 사용자와의 대화를 관리하는 방식에 대한 변경 사항을 발표했습니다. 이번 변경을 통해 사용자가 대화를 통해 이동하는 경로를 더 효과적으로 제어할 수 있게 되었습니다. 자세한 내용은 [Amazon Lex V2의 대화 흐름 변경 사항](understanding-new-flows.md) 단원을 참조하세요. 2022년 8월 17일 이전에 생성된 봇은 대화 코드 후크 메시지, 값 설정, 다음 단계 구성, 조건 추가를 지원하지 않습니다.

## 특정 순서로 프롬프트 구성
<a name="configuring-prompts"></a>

**순서대로 메시지 재생** 확인란을 선택하여 미리 정의된 순서대로 메시지를 재생하도록 봇을 구성할 수 있습니다. 그러지 않으면 봇은 메시지와 그 변형을 무작위 순서로 재생합니다.

순서가 지정된 프롬프트를 사용하면 메시지 및 메시지 그룹의 변형을 재시도할 때 순서대로 재생할 수 있습니다. 사용자가 프롬프트에 대해 잘못된 응답을 하거나 의도를 확인할 때 메시지를 다른 방식으로 바꿀 수 있습니다. 각 슬롯에는 원본 메시지의 최대 두 가지 변형을 설정할 수 있습니다. 메시지를 순서대로 재생할지 무작위로 재생할지 선택할 수 있습니다.

순서가 지정된 프롬프트는 텍스트, 사용자 지정 페이로드 응답, SSML, 카드 그룹 등 4가지 유형의 메시지를 모두 지원합니다. 응답은 동일한 메시지 그룹 내에서 순서가 지정됩니다. 다양한 메시지 그룹은 독립적입니다.

**Topics**
+ [특정 순서로 프롬프트 구성](#configuring-prompts)
+ [샘플 발화](sample-utterances.md)
+ [의도 구조](intent-structure.md)
+ [대화 경로 생성](building-paths.md)
+ [시각적 대화 빌더 사용](visual-conversation-builder.md)
+ [기본 제공 의도](built-in-intents.md)

# 샘플 발화
<a name="sample-utterances"></a>

사용자가 의도를 시작할 때 사용할 것으로 예상되는 문구를 변형한 샘플 발화를 만듭니다. 예를 들어 **BookFlight** 의도의 경우 다음과 같은 발화를 포함할 수 있습니다.

1. 항공편을 예약하고 싶어요

1. 항공편 구하도록 도와주세요.

1. 비행기 표 주세요\$1

1. \$1*DepartureCity*\$1에서 \$1*DestinationCity*\$1행 항공편

10개 이상의 샘플 발화를 제공해야 합니다. 사용자가 발음할 수 있는 다양한 문장 구조와 단어를 나타내는 샘플을 제공합니다. 위의 예시 3 및 4와 같이 불완전한 문장도 고려해 보세요. 예시 4의 \$1*DepartureCity*\$1처럼 슬롯 이름에 중괄호를 사용하여 예시 발화에서 의도에 맞게 정의한 슬롯을 사용할 수도 있습니다. 샘플 발화에 슬롯 이름을 포함하는 경우 Amazon Lex V2는 사용자가 발화에서 제공하는 값으로 의도의 슬롯을 채웁니다.

Amazon Lex V2는 다양한 샘플 발화를 통해 일반화하여 사용자가 의도를 시작하기를 원한다는 것을 효과적으로 인식할 수 있습니다.

의도 편집기, 시각적 대화 빌더에서 또는 [CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html) 또는 [UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html) API 작업을 사용하여 샘플 발화를 추가할 수 있습니다. Amazon Bedrock의 생성형 AI 기능을 활용하여 샘플 표현을 자동으로 생성할 수도 있습니다. 자세한 내용은 [발화 생성을 사용하여 의도 인식을 위한 샘플 발화 생성](utterance-generation.md) 섹션을 참조하세요.

**의도 편집기 또는 시각적 대화 빌더를 사용하세요.**

1. 의도 편집기에서 **샘플 발화** 섹션으로 이동합니다. 시각적 대화 빌더의 **시작** 블록에서 **샘플 발화** 섹션을 찾으세요.

1. 투명한 텍스트 **I want to book a flight**가 있는 상자에 샘플 발화를 입력합니다. **발화 추가**를 선택하여 발화를 추가합니다.

1. **미리 보기** 또는 **일반 텍스트** 모드에서 추가한 샘플 발화를 볼 수 있습니다. **일반 텍스트**에서는 각 줄이 별도의 발화입니다. **미리 보기 모드**에서 발화 위로 마우스를 이동하면 다음 옵션이 표시됩니다.
   + 텍스트 상자를 선택하여 발화 편집.
   + 텍스트 상자 오른쪽에 있는 x 버튼을 선택하여 발화 삭제.
   + 텍스트 상자 왼쪽에 있는 버튼을 드래그하여 샘플 발화의 순서 변경.

1. 상단의 검색 창을 사용하여 샘플 발화를 검색하고 옆에 있는 드롭다운 메뉴를 사용하여 발화를 추가한 순서 또는 알파벳 순서로 정렬할 수 있습니다.

**API 작업 사용**

1. [CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html) 작업으로 새 의도를 생성하거나 [UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html) 작업으로 기존 의도를 업데이트합니다.

1. API 요청에는 [SampleUtterance](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_SampleUtterance.html) 객체의 배열에 매핑되는 `sampleUtterances` 필드가 포함되어 있습니다.

1. 추가하려는 각 샘플 발화에 대해 배열에 `SampleUtterance` 객체를 추가합니다. 샘플 발화를 `utterance` 필드 값으로 추가합니다.

1. 샘플 발화를 편집하고 삭제하려면 `UpdateIntent` 요청을 보내십시오. `sampleUtterances` 필드에 입력한 발화 목록이 기존 발화를 대체합니다.
**중요**  
`UpdateIntent` 요청에서 필드를 비워 두면 의도의 기존 구성이 삭제됩니다. [DescribeIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DescribeIntent.html) 작업을 사용하면 봇 구성을 반환하고 삭제하지 않으려는 구성을 `UpdateIntent` 요청에 복사할 수 있습니다.

# 의도 구조
<a name="intent-structure"></a>

의도는 꽃을 주문하거나 호텔을 예약하는 등 사용자가 달성하고자 하는 목표입니다. 봇에는 의도가 하나 이상 있어야 합니다. 의도는 다음 구성 요소로 구성됩니다.
+ **초기 응답** – 의도가 간접적으로 호출된 후 사용자에게 전송되는 초기 메시지입니다. 응답을 설정하고, 값을 초기화하고, 봇이 의도를 시작할 때 사용자에게 응답하기 위해 취하는 다음 단계를 정의할 수 있습니다.
+ **슬롯** - 의도를 이행하는 데 필요한 파라미터입니다. 각 슬롯에는 슬롯에 입력할 수 있는 값을 정의하는 유형이 있습니다. 사용자 지정 슬롯 유형 중에서 선택하거나 내장 슬롯 유형을 선택할 수 있습니다.
+ **확인** – 사용자와의 대화가 완료되고 의도의 슬롯 값이 채워지면 슬롯 값이 올바른지 사용자에게 묻는 확인 프롬프트를 설정할 수 있습니다.
+ **이행** – 이행 과정에서 사용자에게 전송되는 응답입니다. 이행 시작 시 이행 진행 업데이트를 설정하고 이행을 진행하는 동안 계속해서 정기 업데이트를 전송할 수 있습니다. 이행 후 성공 메시지, 실패 메시지 및 시간 초과 메시지를 설정할 수도 있습니다.
+ **종료 응답** – 의도가 충족되면 종료 응답이 사용자에게 전송됩니다. 종료 응답을 설정하여 대화를 종료하거나 사용자에게 다른 의도를 계속할 수 있음을 알리도록 설정할 수 있습니다.

**Topics**
+ [초기 응답](intent-initial.md)
+ [Slots](intent-slots.md)
+ [확인](intent-confirm.md)
+ [이행](intent-fulfillment.md)
+ [종료 응답](intent-closing.md)

# 초기 응답
<a name="intent-initial"></a>

Amazon Lex V2에서 의도를 확인한 후 슬롯 값을 유도하기 시작하기 전에 사용자에게 초기 응답이 전송됩니다. 이 응답을 사용하여 인식된 의도를 사용자에게 알리고 의도를 이행하기 위해 수집한 정보를 준비할 수 있습니다.

예를 들어 자동차 서비스 약속을 잡으려는 의도가 있는 경우 초기 응답은 다음과 같을 수 있습니다.


|  | 
| --- |
| 예약 예약을 도와드리겠습니다. 차량의 제조사, 모델, 연식을 알려주셔야 합니다. | 

초기 응답 메시지는 필수는 아닙니다. 응답을 제공하지 않는 경우 Amazon Lex V2는 초기 응답의 다음 단계를 계속 따릅니다.

초기 응답 내에서 다음 옵션을 구성할 수 있습니다.
+ **다음 단계 구성** - 대화의 다음 단계(예: 특정 대화 작업으로 이동, 특정 슬롯 유도, 다른 의도로 이동)를 제공할 수 있습니다. 자세한 내용은 [대화의 다음 단계 구성](paths-nextstep.md) 단원을 참조하세요.
+ **값 설정** - 슬롯 및 세션 속성의 값을 설정할 수 있습니다. 자세한 내용은 [대화 중에 값 설정](paths-setting-values.md) 섹션을 참조하세요.
+ **조건부 분기 추가** - 초기 응답을 재생한 후 조건을 적용할 수 있습니다. 조건이 true로 평가되면 정의한 작업이 수행됩니다. 자세한 내용은 [조건을 추가하여 대화 분기 설정](paths-branching.md) 단원을 참조하세요.
+ **대화 코드 후크 실행** - Lambda 코드 후크를 정의하여 데이터를 초기화하고 비즈니스 로직을 실행할 수 있습니다. 자세한 내용은 [대화 코드 후크 간접 호출](paths-code-hook.md) 단원을 참조하세요. 의도에 대해 Lambda 함수를 실행하는 옵션이 활성화된 경우 기본적으로 대화 코드 후크가 실행됩니다. **활성** 버튼을 토글하여 대화 코드 후크를 비활성화할 수 있습니다.

조건이 없거나 명시적인 다음 단계가 없는 경우 Amazon Lex V2는 우선순위에 따라 다음 슬롯으로 이동합니다.

![\[사용자 요청에 대한 초기 응답을 위한 고급 옵션.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/response-initial.png)


**참고**  
2022년 8월 17일, Amazon Lex V2는 사용자와의 대화를 관리하는 방식에 대한 변경 사항을 발표했습니다. 이번 변경을 통해 사용자가 대화를 통해 이동하는 경로를 더 효과적으로 제어할 수 있게 되었습니다. 자세한 내용은 [Amazon Lex V2의 대화 흐름 변경 사항](understanding-new-flows.md) 단원을 참조하세요. 2022년 8월 17일 이전에 생성된 봇은 대화 코드 후크 메시지, 값 설정, 다음 단계 구성, 조건 추가를 지원하지 않습니다.

# Slots
<a name="intent-slots"></a>

슬롯은 의도를 이행하기 위해 사용자가 제공하는 값입니다. 슬롯에는 두 가지 유형이 있습니다.
+ **내장 슬롯 유형** - 내장 슬롯 유형을 사용하여 전화번호, 이름, 도시와 같은 표준 값을 캡처할 수 있습니다. 지원되는 내장 슬롯 유형 목록은 [내장 슬롯 유형](built-in-slots.md) 단원을 참조하세요.
+ **사용자 지정 슬롯 유형** - 사용자 지정 슬롯 유형을 사용하여 의도와 관련된 사용자 지정 값을 캡처할 수 있습니다. 예를 들어, 사용자 지정 슬롯 유형을 사용하여 계좌 유형을 “당좌 예금” 또는 “예금”으로 캡처할 수 있습니다. 자세한 내용은 [사용자 지정 슬롯 유형](custom-slot-types.md) 단원을 참조하세요.

의도에서 슬롯을 정의하려면 다음을 구성해야 합니다.
+ **슬롯 정보** - 이 필드에는 슬롯의 이름과 설명(선택 사항)이 포함되어 있습니다. 예를 들어 슬롯 이름을 “AccountNumber”로 제공하여 계좌 번호를 캡처할 수 있습니다. 의도를 이행하기 위한 대화 흐름의 일부로 슬롯이 필요한 경우 필수로 표시해야 합니다.
+ **슬롯 유형** - 슬롯 유형은 슬롯이 받아들일 수 있는 값 목록을 정의합니다. 사용자 지정 슬롯 유형을 생성하거나 사전 정의된 슬롯 유형을 사용할 수 있습니다.
+ **슬롯 프롬프트** - 슬롯 프롬프트는 정보를 수집하기 위해 사용자에게 제기되는 질문입니다. 정보 수집에 사용되는 재시도 횟수와 각 재시도에 사용되는 프롬프트의 변화를 구성할 수 있습니다. 또한 각 재시도 후에 Lambda 함수 호출을 활성화하여 캡처된 입력을 처리하고 유효한 입력으로 확인을 시도할 수 있습니다.
+ **대기 및 계속(선택 사항)** - 이 동작을 활성화하면 사용자가 “잠시만 기다려주세요”와 같은 문구를 말하여 봇이 정보를 찾아 제공할 때까지 기다리게 할 수 있습니다. 이 기능은 대화 스트리밍에만 사용할 수 있습니다. 자세한 내용은 [일시 중지 동안 사용자가 추가 정보를 제공할 때까지 Amazon Lex V2 봇의 대기 설정 활성화](wait-and-continue.md) 단원을 참조하세요.
+ **슬롯 캡처 응답** - 사용자 입력에서 슬롯 값을 캡처한 결과를 기반으로 성공 응답과 실패 응답을 구성할 수 있습니다.
+ **조건부 분기** – 초기 응답을 재생한 후 조건을 적용할 수 있습니다. 조건이 true로 평가되면 정의한 작업이 수행됩니다. 자세한 내용은 [조건을 추가하여 대화 분기 설정](paths-branching.md) 단원을 참조하세요.
+ **대화 코드 후크** - Lambda 코드 후크를 사용하여 슬롯 값을 검증하고 비즈니스 로직을 실행할 수도 있습니다. 자세한 내용은 [대화 코드 후크 간접 호출](paths-code-hook.md) 단원을 참조하세요.
+ **사용자 입력 유형** - 봇이 특정 양식을 받아들일 수 있도록 입력 유형을 구성할 수 있습니다. 기본적으로 오디오 및 DTMF 양식 모두 허용됩니다. 오디오 전용 또는 DTMF 전용을 옵션으로 설정할 수 있습니다.
+ **오디오 입력 시간 제한 및 길이** - 음성 시간 제한 및 사일런스 시간 제한을 비롯한 오디오 시간 제한을 구성할 수 있습니다. 또한 최대 오디오 길이를 설정할 수 있습니다.
+ **DTMF 입력 시간 제한, 문자 및 길이** – 삭제 문자 및 종료 문자와 함께 DTMF 시간 제한을 설정할 수 있습니다. 또한 최대 DTMF 길이를 설정할 수 있습니다.
+ **텍스트 길이** – 텍스트 양식의 최대 길이를 설정할 수 있습니다.

슬롯 프롬프트가 재생된 후 사용자는 슬롯 값을 입력으로 제공합니다. Amazon Lex V2는 사용자가 제공한 슬롯 값을 인식하지 못하는 경우 값을 이해하거나 슬롯에 대해 구성한 최대 재시도 횟수를 초과할 때까지 슬롯 사용을 재시도합니다. 고급 재시도 설정을 사용하여 시간 제한을 구성하고, 입력 유형을 제한하고, 초기 프롬프트 및 재시도에 대한 인터럽트를 활성화 또는 비활성화할 수 있습니다. 입력 캡처를 시도할 때마다 Amazon Lex V2는 재시도를 위해 제공된 호출 레이블을 사용하여 봇용으로 구성된 Lambda 함수를 호출할 수 있습니다. 예를 들어, Lambda 함수를 사용하여 비즈니스 로직을 적용하고 유효한 값으로 확인하려고 시도할 수 있습니다. 이 Lambda 함수는 슬롯 프롬프트의 **고급 옵션** 내에서 활성화할 수 있습니다.

![\[봇이 정보를 끌어내도록 슬롯 프롬프트를 설정하세요.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/response-slot-prompt.png)


슬롯 값을 입력하거나 최대 재시도 횟수를 초과한 경우 봇이 사용자에게 보내야 하는 응답을 정의할 수 있습니다. 예를 들어 자동차 예약 서비스를 위한 봇의 경우 차량 식별 번호(VIN)를 입력하면 사용자에게 메시지를 보낼 수 있습니다.


|  | 
| --- |
| 차량의 VIN 번호를 제공해 주셔서 감사합니다. 이제 약속을 잡도록 하겠습니다. | 

다음과 같은 두 가지 응답을 생성할 수 있습니다.
+ **성공 응답** – Amazon Lex V2가 슬롯 값을 인식할 때 전송됩니다.
+ **실패 응답** – 최대 재시도 횟수에도 Amazon Lex V2가 사용자의 슬롯 값을 이해할 수 없을 때 전송됩니다.

값을 설정하고, 다음 단계를 구성하고, 각 응답에 해당하는 조건을 적용하여 대화 흐름을 설계할 수 있습니다.

조건이 없거나 명시적인 다음 단계가 없는 경우 Amazon Lex V2는 우선순위에 따라 다음 슬롯으로 이동합니다.

![\[슬롯 응답을 위한 고급 옵션.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/response-slot.png)


Lambda 함수를 사용하여 사용자가 입력한 슬롯 값을 검증하고 다음 작업을 결정할 수 있습니다. 예를 들어 검증 함수를 사용하여 입력한 값이 올바른 범위에 속하는지 또는 형식이 올바른지 확인할 수 있습니다. Lambda 함수를 활성화하려면 **대화 코드 후크** 섹션에서 **Lambda 함수 간접 호출** 확인란과 **활성** 버튼을 선택합니다. 대화 코드 후크에 대한 간접 호출 레이블을 지정할 수 있습니다. 이 간접 호출 레이블은 Lambda 함수에서 슬롯 추출에 해당하는 비즈니스 로직을 작성하는 데 사용할 수 있습니다.

![\[대화 코드 후크 옵션.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/response-dialog-code-hook.png)


의도에 필요하지 않은 슬롯은 기본 대화 흐름에 포함되지 않습니다. 하지만 사용자 발언에 봇이 선택적 슬롯에 해당하는 것으로 식별하는 값이 포함되어 있는 경우 해당 슬롯을 해당 값으로 채울 수 있습니다. 예를 들어 비즈니스 인텔리전스 봇에 선택 사항인 `City` 슬롯이 있고 **What is the sales for April in San Diego?** 사용자 발화가 있으면 봇이 선택 사항 슬롯을 **San Diego**로 채웁니다. 옵션 슬롯 값(있는 경우)을 사용하도록 비즈니스 로직을 구성할 수 있습니다.

의도에 필요하지 않은 슬롯은 다음 단계를 사용하여 끌어낼 수 없습니다. 이러한 단계는 이전 예와 같이 의도 유도 중에만 채우거나 Lambda 함수 내에서 대화 상태를 설정하여 수행할 수 있습니다. Lambda 함수를 사용하여 슬롯을 유도하는 경우 슬롯 추출이 완료된 후 Lambda 함수를 사용하여 대화의 다음 단계를 결정해야 합니다. 봇을 구축하는 동안 다음 단계에 대한 지원을 활성화하려면 슬롯을 의도에 필요한 것으로 표시해야 합니다.

**참고**  
2022년 8월 17일, Amazon Lex V2는 사용자와의 대화를 관리하는 방식에 대한 변경 사항을 발표했습니다. 이번 변경을 통해 사용자가 대화를 통해 이동하는 경로를 더 효과적으로 제어할 수 있게 되었습니다. 자세한 내용은 [Amazon Lex V2의 대화 흐름 변경 사항](understanding-new-flows.md) 단원을 참조하세요. 2022년 8월 17일 이전에 생성된 봇은 대화 코드 후크 메시지, 값 설정, 다음 단계 구성, 조건 추가를 지원하지 않습니다.

다음 항목에서는 이미 채워진 슬롯 값을 다시 불러오도록 봇을 구성하는 방법과 여러 값으로 구성된 슬롯을 만드는 방법을 설명합니다.

**Topics**
+ [슬롯 재유도](reelicit-slots.md)
+ [슬롯에서 여러 값 사용](multi-valued-slots.md)

# 슬롯 재유도
<a name="reelicit-slots"></a>

 이미 채워진 슬롯을 다시 유도하도록 봇을 구성하려면 해당 슬롯 값을 **null**로 설정하고 대화의 다음 단계에서 해당 슬롯을 다시 유도하도록 반복하도록 설정하면 됩니다. 예를 들어, 다음 대화에서처럼 고객이 추가 정보를 근거로 슬롯 유도 확인을 거부한 후에 슬롯을 다시 유도하는 것이 좋습니다.

![\[음식 주문 시 고객의 육류 선호도를 유도하는 대화.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/slots/order-food.png)


의도 편집기 또는 [시각적 대화 빌더 사용](visual-conversation-builder.md)를 사용하여 슬롯을 다시 유도하도록 확인 응답에서 루프를 구성할 수 있습니다.

**참고**  
미리 해당 슬롯 값을 **null**로 설정해 두었다면 대화의 어느 지점에서든 루프백하여 슬롯을 다시 유도할 수 있습니다.

**의도 편집기로 위 예제 재현**

1. 의도 편집기의 **확인** 섹션에서 **의도를 확인하는 프롬프트** 옆의 오른쪽 화살표를 선택하여 섹션을 확장합니다.

1. 하단에서 **고급 옵션**을 선택합니다.

1. **거부 응답** 섹션에서 **값 설정** 옆의 오른쪽 화살표를 선택하여 섹션을 확장합니다. 아래 이미지와 같이 다음 단계로 이 섹션을 채우십시오.

   1. 다시 유도할 슬롯 값을 **null**로 설정합니다. 이 예제에서는 `Meat` 슬롯을 다시 유도하고 싶으므로 **슬롯 값** 섹션에 **\$1Meat\$1 = null**을 입력합니다.

   1. **대화의 다음 단계** 아래에 있는 드롭다운 메뉴에서 **슬롯 유도**를 선택합니다.

   1. **슬롯** 섹션이 나타납니다. 그 아래의 드롭다운 메뉴에서 다시 유도하려는 슬롯을 선택합니다.

   1. **업데이트 옵션**을 선택하여 변경 사항을 확인합니다.  
![\[음식 주문 시 고객의 육류 선호도를 유도하는 대화.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/slots/decline-food.png)

**시각적 대화 빌더를 사용하여 위의 예 재현**

1. **확인** 블록의 **아니요** 포트에서 **슬롯 값 가져오기: Meat** 블록의 수신 포트로의 연결을 생성합니다.  
![\[확인 프롬프트의 거부에서 Meat 슬롯 유도 블록으로의 연결.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/slots/vcb-reelicit-slot-loop.png)

1. **확인** 블록의 오른쪽 상단에 있는 **편집** 아이콘을 선택합니다.  
![\[확인 블록의 오른쪽 상단 모서리에 있는 편집 아이콘.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/slots/vcb-reelicit-slot-confirmation-edit.png)

1. **거부 응답** 섹션에서 봇 응답 옆에 있는 톱니바퀴 아이콘을 선택합니다.  
![\[거부 응답 섹션의 봇 응답 옆에 있는 기어 아이콘\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/slots/vcb-reelicit-slot-confirmation.png)

1. **값 설정** 섹션에서 **슬롯 값** 상자에 "\$1Meat\$1 = null"을 추가합니다.  
![\[값 설정 섹션의 슬롯 값 상자에서 다시 유도할 슬롯 값을 null로 설정합니다.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/slots/vcb-reelicit-slot-set-slot-null.png)

1. **의도 저장**을 선택합니다.

# 슬롯에서 여러 값 사용
<a name="multi-valued-slots"></a>

**참고**  
다중 값 슬롯은 영어(미국) 언어로만 지원됩니다.

일부 의도의 경우 단일 슬롯에 대해 여러 값을 캡처하고 싶을 수 있습니다. 예를 들어 피자 주문 봇은 다음과 같은 발화의 의도를 가지고 있을 수 있습니다.

```
I want a pizza with {toppings}
```

의도는 고객이 피자에 올리고 싶어하는 토핑 목록(예: '페퍼로니와 파인애플')이 `{toppings}` 슬롯에 포함되어 있을 것으로 예상합니다.

여러 값을 캡처하도록 슬롯을 구성하려면 슬롯의 `allowMultipleValues` 필드를 true로 설정합니다. 콘솔을 사용하거나 [CreateSlot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateSlot.html) 또는 [UpdateSlot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateSlot.html) 작업을 사용하여 필드를 설정할 수 있습니다.

사용자 지정 슬롯 유형이 있는 슬롯만 다중 값 슬롯으로 표시할 수 있습니다.

다중 값 슬롯의 경우 Amazon Lex V2는 [RecognizeText](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeText.html) 또는 [RecognizeUtterance](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeUtterance.html) 작업에 대한 응답으로 슬롯 값 목록을 반환합니다. 다음은 OrderPizza 봇에서 “페퍼로니와 파인애플을 곁들인 피자를 원해요”라는 문구에 대해 반환된 슬롯 정보입니다.

```
    "slots": {
        "toppings": {
            "shape": "List",
            "value": {
                "interpretedValue": "pepperoni and pineapple",
                "originalValue": "pepperoni and pineapple",
                "resolvedValues": [
                    "pepperoni and pineapple"
                ]
            },
            "values": [
                {
                    "shape": "Scalar",
                    "value": {
                        "interpretedValue": "pepperoni",
                        "originalValue": "pepperoni",
                        "resolvedValues": [
                            "pepperoni"
                        ]
                    }
                },
                {
                    "shape": "Scalar",
                    "value:": {
                        "interpretedValue": "pineapple",
                        "originalValue": "pineapple",
                        "resolvedValues": [
                            "pineapple"
                        ]
                    }
                }
            ]
        }
    }
```

다중 값 슬롯은 항상 값 목록을 반환합니다. 발화에 하나의 값만 포함된 경우 반환된 값 목록에는 하나의 응답만 포함됩니다.

Amazon Lex V2는 공백, 쉼표(,) 및 ‘and’ 접속사로 구분된 여러 값을 인식합니다. 다중 값 슬롯은 텍스트 및 음성 입력 모두에 사용할 수 있습니다.

프롬프트에 다중 값 슬롯을 사용할 수 있습니다. 예를 들어 의도에 대한 확인 프롬프트를 다음과 같이 설정할 수 있습니다.

```
Would you like me to order your {toppings} pizza?
```

Amazon Lex V2가 사용자에게 메시지를 보내면 “페퍼로니와 파인애플 피자를 주문하시겠습니까?” 라는 메시지가 표시됩니다.

다중 값 슬롯은 단일 기본값을 지원합니다. 여러 기본값이 제공되는 경우 Amazon Lex V2는 사용 가능한 첫 번째 값만 슬롯을 채웁니다. 자세한 내용은 [Lex V2 봇에서 의도에 기본 슬롯 값 사용](context-mgmt-default.md) 단원을 참조하십시오.

슬롯 난독화를 사용하여 대화 로그에 있는 다중 값 슬롯의 값을 마스킹할 수 있습니다. 슬롯 값을 난독화하면 각 슬롯 값의 값이 슬롯의 이름으로 대체됩니다. 자세한 내용은 [Lex V2에서 대화 로그의 슬롯 값 가리기](monitoring-obfuscate.md) 단원을 참조하십시오.

# 확인
<a name="intent-confirm"></a>

사용자와의 대화가 완료되고 의도의 슬롯 값이 채워지면 슬롯 값이 올바른지 사용자에게 묻는 확인 프롬프트를 구성할 수 있습니다. 예를 들어 자동차 서비스 약속을 예약하는 봇은 사용자에게 다음과 같은 메시지를 표시할 수 있습니다.


|  | 
| --- |
| 2017년 혼다 시빅의 서비스가 3월 25일 오후 3시로 예정되어 있습니다. 일정 괜찮으신가요? | 

확인 프롬프트에는 세 가지 유형의 응답을 정의할 수 있습니다.
+ **확인 응답** – 이 응답은 사용자가 의도를 확인하면 사용자에게 전송됩니다. 예를 들어, 사용자가 “주문하시겠습니까?”라는 프롬프트에 “예”라고 답한 후입니다.
+ **거부 응답** – 이 응답은 사용자가 의도를 거부할 때 사용자에게 전송됩니다. 예를 들어, 사용자가 “주문하시겠습니까?”라는 프롬프트에 “아니요”라고 답한 후입니다.
+ **실패 응답** – 이 응답은 확인 메시지를 처리할 수 없는 경우 사용자에게 전송됩니다. 예를 들어, 사용자의 응답을 이해할 수 없거나 예 또는 아니오로 해결할 수 없는 경우입니다.

![\[확인 및 거부 응답에 대한 3가지 유형의 응답을 보여주는 순서도.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/conditional-confirmation-flow.png)


확인 메시지를 지정하지 않으면 Amazon Lex V2가 이행 단계 또는 종료 응답으로 이동합니다.

값을 설정하고, 다음 단계를 구성하고, 각 응답에 해당하는 조건을 적용하여 대화 흐름을 설계할 수 있습니다. 조건이 없거나 명확한 다음 단계가 없는 경우 Amazon Lex V2는 이행 단계로 이동합니다.

또한 대화 코드 후크를 활성화하여 이행을 위해 정보를 보내기 전에 의도에 캡처된 정보의 유효성을 검사할 수 있습니다. 코드 후크를 사용하려면 확인 프롬프트 고급 옵션에서 대화 코드 후크를 활성화하세요. 또한 이전 상태의 다음 단계를 구성하여 대화 코드 후크를 실행합니다. 자세한 내용은 [대화 코드 후크 간접 호출](paths-code-hook.md) 단원을 참조하세요.

**참고**  
 코드 후크를 사용하여 런타임에 확인 단계를 트리거하는 경우 빌드 시 확인 단계를 **활성**으로 표시해야 합니다.

![\[Amazon Lex V2 콘솔에는 확인 프롬프트에 대한 고급 옵션이 표시됩니다.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/response-confirm.png)


**참고**  
2022년 8월 17일, Amazon Lex V2는 사용자와의 대화를 관리하는 방식에 대한 변경 사항을 발표했습니다. 이번 변경을 통해 사용자가 대화를 통해 이동하는 경로를 더 효과적으로 제어할 수 있게 되었습니다. 자세한 내용은 [Amazon Lex V2의 대화 흐름 변경 사항](understanding-new-flows.md) 단원을 참조하세요. 2022년 8월 17일 이전에 생성된 봇은 대화 코드 후크 메시지, 값 설정, 다음 단계 구성, 조건 추가를 지원하지 않습니다.

## Lambda 함수를 사용하여 의도를 검증합니다.
<a name="intent-confirm-codehook"></a>

Lambda 코드 후크를 정의하여 이행을 위해 의도를 전송하기 전에 의도를 검증할 수 있습니다. 코드 후크를 사용하려면 확인 프롬프트 고급 옵션에서 대화 코드 후크를 활성화하세요.

코드 후크를 사용하면 코드 후크가 실행된 후 Amazon Lex V2가 수행하는 작업을 정의할 수 있습니다. 세 가지 유형의 응답을 만들 수 있습니다.
+ **성공 응답** – 코드 후크가 성공적으로 완료되면 사용자에게 전송됩니다.
+ **실패 응답** – 코드 후크가 성공적으로 실행되지 않거나 응답에서 코드 후크가 `Failure`를 반환할 때 사용자에게 전송됩니다.
+ **시간 초과 응답** – 코드 후크가 구성된 시간 제한 기간 내에 완료되지 않을 때 사용자에게 전송됩니다.

# 이행
<a name="intent-fulfillment"></a>

사용자가 의도에 대해 모든 슬롯 값을 제공하면 Amazon Lex V2가 사용자의 요청을 처리합니다. 이행을 위해 다음 옵션을 구성할 수 있습니다.
+ **이행 코드 후크** - 이 옵션을 사용하여 이행 Lambda 호출을 제어할 수 있습니다. 옵션이 비활성화되면 Lambda 함수를 간접적으로 호출하지 않고도 이행이 성공합니다.
+ **이행 업데이트** - 완료하는 데 몇 초 이상 걸리는 Lambda 함수에 대한 이행 업데이트를 활성화하여 사용자가 프로세스가 진행 중임을 알 수 있도록 할 수 있습니다. 자세한 내용은 [Lex V2 봇의 이행 진행 업데이트 구성](streaming-progress.md) 단원을 참조하세요. 이 기능은 스트리밍 대화에만 사용할 수 있습니다.
+ **이행 응답** – 성공 응답, 실패 응답 및 제한 시간 응답을 구성할 수 있습니다. 이행 Lambda 간접 호출 상태를 기반으로 사용자에게 적절한 응답이 반환됩니다.

이행 응답은 세 가지가 가능합니다.
+ **성공 응답** - Lambda 이행이 성공적으로 완료될 때 전송되는 메시지입니다.
+ **실패 응답** – 이행이 실패하거나 어떤 이유로 Lambda를 완료할 수 없는 경우 전송되는 메시지입니다.
+ **시간 초과 응답** - 이행 Lambda 함수가 구성된 시간 제한 내에 완료되지 않을 경우 전송되는 메시지입니다.

값을 설정하고, 다음 단계를 구성하고, 각 응답에 해당하는 조건을 적용하여 대화 흐름을 설계할 수 있습니다. 조건이 없거나 명확한 다음 단계가 없는 경우 Amazon Lex V2는 종료 응답으로 이동합니다.

![\[Amazon Lex V2 콘솔에는 이행 코드 후크에 대한 응답 옵션이 표시됩니다.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/response-fulfillment.png)


**참고**  
2022년 8월 17일, Amazon Lex V2는 사용자와의 대화를 관리하는 방식에 대한 변경 사항을 발표했습니다. 이번 변경을 통해 사용자가 대화를 통해 이동하는 경로를 더 효과적으로 제어할 수 있게 되었습니다. 자세한 내용은 [Amazon Lex V2의 대화 흐름 변경 사항](understanding-new-flows.md) 단원을 참조하세요. 2022년 8월 17일 이전에 생성된 봇은 대화 코드 후크 메시지, 값 설정, 다음 단계 구성, 조건 추가를 지원하지 않습니다.

# 종료 응답
<a name="intent-closing"></a>

의도가 충족되면 종료 응답이 사용자에게 전송됩니다. 종료 응답을 사용하여 대화를 종료하거나 사용자에게 다른 의도를 계속할 수 있음을 알리는 데 사용할 수 있습니다. 예를 들어 여행 예약 봇에서 호텔 객실 예약 의도의 종료 응답을 다음과 같이 설정할 수 있습니다.


|  | 
| --- |
| 됐습니다. 호텔 객실을 예약했습니다. 더 도와드릴 일이 있으신가요? | 

값을 설정하고, 다음 단계를 구성하고, 종료 응답 후 조건을 적용하여 대화 경로를 설계할 수 있습니다. 조건이 없거나 명확한 다음 단계가 없는 경우 Amazon Lex V2는 대화를 종료합니다.

종료 응답을 제공하지 않거나 어떤 조건도 true로 평가되지 않으면 Amazon Lex V2는 봇과의 대화를 종료합니다.

![\[Amazon Lex V2 콘솔에는 종료 응답 옵션이 표시됩니다.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/response-closing.png)


**참고**  
2022년 8월 17일, Amazon Lex V2는 사용자와의 대화를 관리하는 방식에 대한 변경 사항을 발표했습니다. 이번 변경을 통해 사용자가 대화를 통해 이동하는 경로를 더 효과적으로 제어할 수 있게 되었습니다. 자세한 내용은 [Amazon Lex V2의 대화 흐름 변경 사항](understanding-new-flows.md) 단원을 참조하세요. 2022년 8월 17일 이전에 생성된 봇은 대화 코드 후크 메시지, 값 설정, 다음 단계 구성, 조건 추가를 지원하지 않습니다.

# 대화 경로 생성
<a name="building-paths"></a>

일반적으로 Amazon Lex V2는 사용자와의 대화 흐름을 관리합니다. 단순 봇의 경우 기본 흐름만으로도 사용자에게 좋은 경험을 제공할 수 있습니다. 하지만 좀 더 복잡한 봇의 경우 사용자가 대화를 제어하고 흐름을 더 복잡한 경로로 안내할 수 있습니다.

예를 들어 렌터카를 예약하는 봇에서는 어린 운전자에게 렌터카를 대여하지 않을 수 있습니다. 이 경우 운전자가 특정 연령 미만인지 확인하는 조건을 만들고, 연령 미만인 경우 종료 응답으로 이동할 수 있습니다.

![\[24세 미만의 운전자에게 대여하지 않는 렌터카 봇의 대화 흐름을 보여주는 순서도.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/conditional-flowchart.png)


이러한 상호 작용을 설계하려면 대화의 각 지점에서 다음 단계를 구성하고, 조건을 평가하고, 값을 설정하고, 코드 후크를 간접적으로 호출할 수 있습니다.

조건부 분기를 사용하면 복잡한 상호 작용을 통해 사용자를 위한 경로를 만들 수 있습니다. 대화의 제어권을 봇에게 넘겨주는 시점에서는 언제든지 조건부 분기를 사용할 수 있습니다. 예를 들어 봇이 첫 번째 슬롯 값을 유도하기 전에 조건을 만들거나, 각 슬롯 값의 유도 사이에 조건을 만들거나, 봇이 대화를 종료하기 전에 조건을 만들 수 있습니다. 조건을 추가할 수 있는 위치 목록은 [의도 추가](add-intents.md)를 참조하세요.

봇을 생성하면 Amazon Lex V2가 슬롯의 우선순위에 따라 대화를 통한 기본 경로를 생성합니다. 대화 경로를 사용자 지정하려면 대화의 어느 시점에서든 다음 단계를 수정하면 됩니다. 자세한 내용은 [대화의 다음 단계 구성](paths-nextstep.md) 단원을 참조하세요.

조건에 따라 대체 경로를 만들려면 대화의 어느 시점에서든 조건부 분기를 사용하면 됩니다. 예를 들면, 봇이 첫 번째 슬롯 값을 유도하기 전에 조건을 만들 수 있습니다. 각 슬롯 값의 유도 사이에 조건을 만들거나 봇이 대화를 종료하기 전에 조건을 만들 수 있습니다. 조건을 추가할 수 있는 위치 목록은 [조건을 추가하여 대화 분기 설정](paths-branching.md)를 참조하세요.

슬롯 값, 세션 속성, 입력 모드 및 입력 기록 또는 Amazon Kendra의 응답을 기반으로 조건을 설정할 수 있습니다.

대화의 각 시점에서 슬롯 및 세션 속성 값을 설정할 수 있습니다. 자세한 내용은 [대화 중에 값 설정](paths-setting-values.md) 단원을 참조하세요.

다음 작업을 대화 코드 후크로 설정하여 Lambda 함수를 실행할 수도 있습니다. 자세한 내용은 [대화 코드 후크 간접 호출](paths-code-hook.md) 단원을 참조하세요.

다음 이미지는 콘솔의 슬롯 경로 생성을 보여줍니다. 이 예시에서 Amazon Lex V2는 “age” 슬롯을 유도합니다. 슬롯 값이 24보다 작으면 Amazon Lex V2가 종료 응답으로 점프합니다. 그렇지 않으면 Amazon Lex V2가 기본 경로를 따릅니다.

![\[슬롯에 대한 조건 편집기를 보여주는 Amazon Lex V2 콘솔입니다.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/conditional-slot.png)


**참고**  
2022년 8월 17일, Amazon Lex V2는 사용자와의 대화를 관리하는 방식에 대한 변경 사항을 발표했습니다. 이번 변경을 통해 사용자가 대화를 통해 이동하는 경로를 더 효과적으로 제어할 수 있게 되었습니다. 자세한 내용은 [Amazon Lex V2의 대화 흐름 변경 사항](understanding-new-flows.md) 단원을 참조하세요. 2022년 8월 17일 이전에 생성된 봇은 대화 코드 후크 메시지, 값 설정, 다음 단계 구성, 조건 추가를 지원하지 않습니다.

# 대화의 다음 단계 구성
<a name="paths-nextstep"></a>

대화의 각 단계에서 다음 단계를 구성하여 대화를 설계할 수 있습니다. 일반적으로 Amazon Lex V2는 다음 순서에 따라 대화의 각 단계에 대한 기본 다음 단계를 자동으로 구성합니다.

 초기 응답 → 슬롯 유도 → 확인(활성화된 경우) → 이행(활성화된 경우) → 종료 응답(활성화된 경우) → 대화 종료

기본 다음 단계를 수정하고 예상 사용자 경험을 기반으로 대화를 설계할 수 있습니다. 대화의 각 단계에서 다음과 같은 다음 단계를 구성할 수 있습니다.

**다음으로 이동**
+ **초기 응답** – 의도의 시작부터 대화가 다시 시작됩니다. 이 다음 단계를 구성하는 동안 초기 응답을 건너뛰도록 선택할 수 있습니다.
+ **슬롯 유도** - 의도의 모든 슬롯을 유도할 수 있습니다.
+ **조건 평가** – 대화의 어느 단계에서든 조건을 평가하고 대화의 분기를 나눌 수 있습니다.
+ **대화 코드 후크 간접 호출** – 어느 단계에서든 비즈니스 로직을 간접적으로 호출할 수 있습니다.
+ **의도 확인** – 의도를 확인하라는 메시지가 사용자에게 표시됩니다.
+ **의도 이행** – 의도 이행은 다음 단계부터 시작됩니다.
+ **종료 응답** – 종료 응답이 사용자에게 반환됩니다.

**다음으로 전환**
+ **의도** – 다른 의도로 전환하여 이 의도에 대한 대화를 계속할 수 있습니다. 전환하는 동안 의도의 초기 응답을 건너뛸 수도 있습니다.
+ **의도: 특정 슬롯** – 현재 의도에서 일부 슬롯 값을 이미 캡처한 경우 다른 의도에서 특정 슬롯을 직접 유도할 수 있습니다.

**사용자 입력 대기** – 봇은 사용자가 새로운 의도를 인식하기 위한 입력을 제공할 때까지 기다립니다. 다음 단계를 설정하기 전에 “제가 도와드릴 수 있는 다른 사항이 있나요?”와 같은 프롬프트를 구성할 수 있습니다. 봇은 `ElicitIntent` 대화 상태가 됩니다.

**대화 종료** – 봇과의 대화가 종료됩니다.

**참고**  
2022년 8월 17일, Amazon Lex V2는 사용자와의 대화를 관리하는 방식에 대한 변경 사항을 발표했습니다. 이번 변경을 통해 사용자가 대화를 통해 이동하는 경로를 더 효과적으로 제어할 수 있게 되었습니다. 자세한 내용은 [Amazon Lex V2의 대화 흐름 변경 사항](understanding-new-flows.md) 단원을 참조하세요. 2022년 8월 17일 이전에 생성된 봇은 대화 코드 후크 메시지, 값 설정, 다음 단계 구성, 조건 추가를 지원하지 않습니다.

# 대화 중에 값 설정
<a name="paths-setting-values"></a>

Amazon Lex V2는 대화의 모든 단계에서 슬롯 값과 세션 속성 값을 설정하는 기능을 제공합니다. 그런 다음 대화 중에 이 값을 사용하여 조건을 평가하거나 의도 이행 중에 사용할 수 있습니다.

현재 의도의 슬롯 값을 설정할 수 있습니다. 대화의 다음 단계가 다른 의도를 간접적으로 호출하는 것이라면 새 의도의 슬롯 값을 설정할 수 있습니다.

할당된 슬롯이 채워지지 않았거나 JSON 경로를 구문 분석할 수 없는 경우 속성은 `null`로 설정됩니다.

슬롯 값 및 세션 속성을 사용할 때는 다음 구문을 사용하세요.
+ **슬롯 값** – 슬롯 이름을 중괄호("\$1 \$1")로 묶습니다. 현재 의도의 슬롯 값에는 슬롯 이름만 사용하면 됩니다. 예를 들어 `{slot}`입니다. 다음 의도에서 값을 설정하는 경우 의도 이름과 슬롯 이름을 모두 사용하여 슬롯을 식별해야 합니다. 예를 들어 `{intent.slot}`입니다.

  예시:
  +  `{PhoneNumber} = "1234567890"` 
  +  `{CheckBalance.AccountNumber} = "99999999"` 
  +  `{BookingID} = "ABC123"` 
  +  `{FirstName} = "John"` 

  슬롯 값은 다음 중 하나일 수 있습니다.
  + 상수 문자열
  + Amazon Lex 응답의 트랜스크립션 블록을 참조하는 JSON 경로(en-US 및 en-GB의 경우)
  + 세션 속성

  예:
  +  `{username} = "john.doe" ` 
  +  `{username_confidence} = $.transcriptions[0].transcriptionConfidence ` 
  +  `{username_slot_value} = [username] ` 
**참고**  
슬롯 값을 `null`로 설정할 수도 있습니다. 이미 채워진 슬롯 값을 다시 유도해야 하는 경우 고객에게 슬롯 값을 다시 입력하라는 메시지를 표시하기 전에 값을 `null`로 설정해야 합니다. 할당된 슬롯이 채워지지 않았거나 JSON 경로를 구문 분석할 수 없는 경우 속성은 `null`로 설정됩니다.
+ **세션 속성** – 속성 이름을 대괄호("[ ]")로 묶습니다. 예를 들어 `[sessionAttribute]`입니다.

  예시:
  +  ` [username] = "john.doe" ` 
  +  ` [username_confidence] = $.transcriptions[0].transcriptionConfidence ` 
  +  ` [username_slot_value] = {username} ` 

  세션 속성 값은 다음 중 하나일 수 있습니다.
  + 상수 문자열
  + Amazon Lex 응답의 트랜스크립션 블록을 참조하는 JSON 경로(en-US 및 en-GB의 경우)
  + 슬롯 값 참조
**참고**  
할당된 슬롯이 채워지지 않았거나 JSON 경로를 구문 분석할 수 없는 경우 속성은 `null`로 설정됩니다.

**참고**  
2022년 8월 17일, Amazon Lex V2는 사용자와의 대화를 관리하는 방식에 대한 변경 사항을 발표했습니다. 이번 변경을 통해 사용자가 대화를 통해 이동하는 경로를 더 효과적으로 제어할 수 있게 되었습니다. 자세한 내용은 [Amazon Lex V2의 대화 흐름 변경 사항](understanding-new-flows.md) 단원을 참조하세요. 2022년 8월 17일 이전에 생성된 봇은 대화 코드 후크 메시지, 값 설정, 다음 단계 구성, 조건 추가를 지원하지 않습니다.

# 조건을 추가하여 대화 분기 설정
<a name="paths-branching"></a>

*조건부 분기*를 사용하여 고객이 봇과의 대화를 통해 이동하는 경로를 제어할 수 있습니다. 슬롯 값, 세션 속성, 입력 모드 및 입력 트랜스크립트 필드의 내용 또는 Amazon Kendra의 응답을 기반으로 대화를 분기할 수 있습니다.

최대 4개의 분기를 정의할 수 있습니다. Amazon Lex V2가 해당 분기를 따르려면 각 분기에 충족해야 하는 조건이 있습니다. 조건을 충족하는 분기가 하나도 없는 경우 기본 분기를 따릅니다.

분기를 정의할 때는 해당 분기에 해당하는 조건이 true로 평가될 경우 Amazon Lex V2가 수행해야 하는 작업을 정의합니다. 다음과 같은 작업을 정의할 수 있습니다.
+ 사용자에게 전송된 응답.
+ 슬롯에 적용할 슬롯 값.
+ 현재 세션에 대한 세션 속성 값.
+ 대화의 다음 단계. 자세한 내용은 [대화 경로 생성](building-paths.md) 단원을 참조하세요.

![\[조건부 분기를 위한 다양한 옵션을 선택할 수 있습니다.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/conditional-choose.png)


각 조건부 분기에는 Amazon Lex V2가 분기를 따르려면 반드시 충족해야 하는 부울 표현식이 있습니다. 조건에 따라 사용할 수 있는 비교 연산자와 부울 연산자, 함수 및 수량자 연산자가 있습니다. 예를 들어, \$1age\$1 슬롯이 24보다 작으면 다음 조건이 true를 반환합니다.

```
{age} < 24
```

\$1toppings\$1 다중 값 슬롯에 “pineapple”이라는 단어가 포함된 경우 다음 조건은 true를 반환합니다.

```
{toppings} CONTAINS "pineapple"
```

더 복잡한 조건을 위해 여러 비교 연산자를 부울 연산자와 결합할 수 있습니다. 예를 들어 \$1make\$1 슬롯 값이 “Honda”이고 \$1model\$1 슬롯 값이 “Civic”인 경우 다음 조건은 true를 반환합니다. 괄호를 사용하여 평가 순서를 설정합니다.

```
({make} = "Honda") AND ({model} = "Civic")
```

다음 항목에서는 조건부 분기 연산자 및 함수에 대한 세부 정보를 제공합니다.

**참고**  
2022년 8월 17일, Amazon Lex V2는 사용자와의 대화를 관리하는 방식에 대한 변경 사항을 발표했습니다. 이번 변경을 통해 사용자가 대화를 통해 이동하는 경로를 더 효과적으로 제어할 수 있게 되었습니다. 자세한 내용은 [Amazon Lex V2의 대화 흐름 변경 사항](understanding-new-flows.md) 단원을 참조하세요. 2022년 8월 17일 이전에 생성된 봇은 대화 코드 후크 메시지, 값 설정, 다음 단계 구성, 조건 추가를 지원하지 않습니다.

**Topics**
+ [비교 연산자](#branching-comparison)
+ [부울 연산](#branching-boolean)
+ [수량화 연산자](#branching-quentifier)
+ [함수](#branching-function)
+ [조건식 샘플](#sample-conditional-expressions)

## 비교 연산자
<a name="branching-comparison"></a>

Amazon Lex V2는 조건에 대해 다음과 같은 비교 연산자를 지원합니다.
+ 같음(=)
+ 같지 않음(\$1=)
+ 작음(<)
+ 작거나 같음(<=)
+ 큼 (>)
+ 크거나 같음(>=)

비교 연산자를 사용할 때는 다음 규칙을 사용합니다.
+ 왼쪽은 참조여야 합니다. 예를 들어 슬롯 값을 참조하려면 `{slotName}`을 사용합니다. 세션 속성 값을 참조하려면 `[attribute]`를 사용합니다. 입력 모드 및 입력 트랜스크립트의 경우 `$.inputMode` 및 `$.inputTranscript`를 사용합니다.
+ 오른쪽은 상수이고 왼쪽과 같은 유형이어야 합니다.
+ 설정되지 않은 속성을 참조하는 모든 표현식은 유효하지 않은 것으로 처리되며 평가되지 않습니다.
+ 다중 값 슬롯을 비교할 때 사용되는 값은 해석된 모든 값을 쉼표로 구분한 목록입니다.

비교는 참조의 슬롯 유형을 바탕으로 합니다. 다음과 같이 확인합니다.
+ **문자열 ** – 문자열은 ASCII 표현을 기준으로 비교됩니다. 이 비교는 대문자 및 소문자를 구분하지 않습니다.
+ **숫자** – 숫자 기반 슬롯을 문자열 표현에서 숫자로 변환한 다음 비교합니다.
+ **날짜 및 시간** – 시간 기반 슬롯은 시계열을 기준으로 비교됩니다. 더 이른 날짜나 시간은 더 작은 것으로 간주됩니다. 기간의 경우 기간이 짧을수록 더 짧은 기간으로 간주됩니다.

## 부울 연산
<a name="branching-boolean"></a>

Amazon Lex V2는 비교 연산자를 조합할 수 있는 부울 연산자를 지원합니다. 연산자를 통해 다음과 유사한 명령문을 만들 수 있습니다.

```
({number} >= 5) AND ({number} <= 10)
```

다음과 같은 부울 연산자를 사용할 수 있습니다.
+ AND (&&)
+ OR (\$1\$1)
+ NOT (\$1)

## 수량화 연산자
<a name="branching-quentifier"></a>

수량자 연산자는 수열의 요소를 평가하여 하나 이상의 요소가 조건을 충족하는지 확인합니다.
+ **CONTAINS** – 지정된 값이 다중 값 슬롯에 포함되어 있는지 확인하고, 포함된 경우 true를 반환합니다. 예를 들어, `{toppings} CONTAINS "pineapple"`은 사용자가 피자에 파인애플을 주문하면 true를 반환합니다.

## 함수
<a name="branching-function"></a>

함수 앞에는 문자열 `fn.`이 와야 합니다. 함수의 인수는 슬롯, 세션 속성 또는 요청 속성에 대한 참조입니다. Amazon Lex V2는 슬롯의 값에서 정보를 가져오기 위한 두 가지 함수, 세션 속성 또는 요청 속성을 제공합니다.
+ **fn.COUNT()** – 다중 값 슬롯의 값 수를 계산합니다.

  예를 들어 `{toppings}` 슬롯에 “pepperoni, pineapple” 값이 포함된 경우:

  `fn.COUNT({toppings}) = 2`
+ **fn.IS\$1SET()** – 슬롯, 세션 속성 또는 요청 속성이 현재 세션에 설정된 경우 값은 true입니다.

  이전 예를 기반으로 설정:

  `fn.IS_SET({toppings})`
+ **fn.LENGTH()** - 값은 현재 세션에 설정된 세션 특성, 슬롯 값 또는 슬롯 특성 값의 길이입니다. 이 함수는 다중 값 슬롯 또는 복합 슬롯을 지원하지 않습니다.

  예제:

  `{credit-card-number}` 슬롯에 “123456781234” 값이 포함될 경우:

  `fn.LENGTH({credit-card-number}) = 12`

## 조건식 샘플
<a name="sample-conditional-expressions"></a>

다음은 몇 가지 조건식 예시입니다. 참고:는 Amazon Lex V2 JSON 응답의 진입점을 `$.` 나타냅니다. 다음 값은 Amazon Lex V2 응답 내에서 `$.` 구문 분석되어 값을 검색합니다. Amazon Lex V2 응답에서 트랜스크립션 블록에 대한 JSON 경로 참조를 사용하는 조건식은 ASR 트랜스크립션 점수를 지원하는 동일한 로캘에서만 지원됩니다.


| 값 유형 | 사용 사례: | 조건식 | 
| --- | --- | --- | 
| 사용자 지정 슬롯 | pizzaSize 슬롯 값이 라지와 같음 | \$1pizzaSize\$1 = "large" | 
| 사용자 지정 슬롯 | pizzaSize는 라지 또는 미디엄과 같음 | \$1pizzaSize\$1 = "large" OR \$1pizzaSize\$1 = "medium"  | 
| 사용자 지정 슬롯 | () 및 AND/OR가 포함된 표현식 | \$1pizzaType\$1 = "pepperoni" OR \$1pizzaSize\$1 = "medium" OR \$1pizzaSize\$1 = "small"  | 
| 사용자 지정 슬롯(다중 값 슬롯) | 토핑 중 하나가 양파인지 확인 | \$1toppings\$1 CONTAINS "Onion" | 
| 사용자 지정 슬롯(다중 값 슬롯) | 토핑 수가 3개 이상 | fn.COUNT(\$1topping\$1) > 2 | 
| AMAZON.AlphaNumeric | bookingID는 ABC123 | \$1bookingID\$1 = "ABC123" | 
| AMAZON.Number | 연령 슬롯 값이 30보다 큼 | \$1age\$1 > 30 | 
| AMAZON.Number | 연령 슬롯 값이 10과 같음 | \$1age\$1 = 10 | 
| AMAZON.Date | 1990년 이전의 dateOfBirth 슬롯 값 | \$1dateOfBirth\$1 < "1990-10-01" | 
| AMAZON.State | destinationState 슬롯 값이 워싱턴과 같음 | \$1destinationState\$1 = "washington" | 
| AMAZON.Country | destinationCountry 슬롯 값이 미국이 아님 | \$1destinationCountry\$1 \$1= "united states" | 
| AMAZON.FirstName | firstName 슬롯 값이 John임 | \$1firstName\$1 = "John" | 
| AMAZON.PhoneNumber | phoneNumber 슬롯 값이 716767891932임 | \$1phoneNumer\$1 = 716767891932 | 
| AMAZON.Percentage | 백분율 슬롯 값이 78보다 크거나 같은지 확인 | \$1percentage\$1 >= 78 | 
| AMAZON.EmailAddress | emailAddress 슬롯 값이 userA@hmail.com임 | \$1emailAddress\$1 = "userA@hmail.com" | 
| AMAZON.LastName | lastName 슬롯 값이 Doe임 | \$1lastName\$1 = "Doe" | 
| AMAZON.City | 시티 슬롯 값이 시애틀과 같음 | \$1city\$1 = "Seattle" | 
| AMAZON.Time | 시간은 오후 8시 이후임 | \$1time\$1 > "20:00" | 
| AMAZON.StreetName | streetName 슬롯 값이 Boren Avenue임 | \$1streetName\$1 = "boren avenue" | 
| AMAZON.Duration | travelDuration 슬롯 값이 2시간 미만임 | \$1travelDuration\$1 < P2H | 
| 입력 모드 | 입력 모드는 음성 | \$1.inputMode = "Speech" | 
| 입력 대화 기록 | 입력 대화 기록은 "I want a large pizza"와 같음 | \$1.inputTranscript = "I want a large pizza" | 
| 세션 속성 | customer\$1subscription\$1type 속성 확인 | [customer\$1subcription\$1type] = "yearly" | 
| 요청 속성 | retry\$1enabled 플래그 확인 | ((retry\$1enabled)) = "TRUE" | 
| Kendra 응답 | Kendra 응답에 FAQ 포함됨 | fn.IS\$1SET(((x-amz-lex:kendra-search-response-question\$1answer-question-1))) | 
| 트랜스크립션을 사용한 조건식) | 트랜스크립션 JSON 경로를 사용한 조건식 | \$1.transcriptions[0].transcriptionConfidence < 0.8 AND \$1.transcriptions[1].transcriptionConfidence > 0.5 | 
| 세션 속성 설정 | 트랜스크립션, JSON 경로 및 슬롯 값을 사용하여 세션 속성 설정 | [sessionAttribute] = "\$1.transcriptions..." AND [sessionAttribute] = "\$1<slotName>\$1" | 
| 슬롯 값 설정 | 세션 속성 및 트랜스크립션 JSON 경로를 사용하여 슬롯 값 설정 | \$1slotName\$1 = [<sessionAttribute>] AND \$1slotName\$1 = "\$1.transcriptions..." | 

**참고**  
`slotName`는 Amazon Lex V2 봇의 슬롯 이름을 나타냅니다. 슬롯이 확인되지 않거나(null) 슬롯이 없는 경우 런타임에 할당이 무시됩니다. `sessionAttribute`는 빌드 시 고객이 설정하는 세션 속성의 이름을 나타냅니다.

# 대화 코드 후크 간접 호출
<a name="paths-code-hook"></a>

Amazon Lex V2가 사용자에게 메시지를 보낼 때 대화의 각 단계에서 Lambda 함수를 대화의 다음 단계로 사용할 수 있습니다. 함수를 사용하여 대화의 현재 상태를 기반으로 비즈니스 로직을 구현할 수 있습니다.

실행되는 Lambda 함수는 사용 중인 봇 별칭과 연결됩니다. 의도의 모든 대화상자 코드 후크에서 Lambda 함수를 간접적으로 호출하려면 의도에 **초기화 및 검증에 Lambda 함수 사용**을 선택해야 합니다. Lambda 함수 선택에 대한 자세한 내용은 [Amazon Lex V2 봇에 대한 AWS Lambda함수 생성](lambda-attach.md) 단원을 참조하세요.

두 단계를 통해 Lambda 함수를 사용할 수 있습니다. 먼저 대화의 어느 시점에서든 대화 코드 후크를 활성화해야 합니다. 둘째, 대화의 다음 단계에서 대화 코드 후크를 사용하도록 설정해야 합니다.

다음 이미지는 활성화된 대화 코드 후크를 보여줍니다.

![\[조건부 응답 코드 후크가 활성 상태임을 보여줍니다.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/code-hook-active.png)


다음으로, 코드 후크를 대화 단계의 다음 동작으로 설정합니다. 대화의 다음 단계를 대화 코드 후크 간접 호출로 구성하여 이 작업을 수행할 수 있습니다. 다음 이미지는 대화의 기본 경로에 대한 다음 단계로 대화 코드 후크를 호출하는 조건부 분기를 보여줍니다.

![\[대화의 다음 단계로 코드 후크를 보여 주는 조건부 분기.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/code-hook-choose.png)


코드 후크가 활성화되면 사용자에게 반환할 응답 3개를 설정할 수 있습니다.
+ **성공** - Lambda 함수가 성공적으로 완료되었을 때 전송됩니다.
+ **실패** – Lambda 함수를 실행하는 데 문제가 있거나 Lambda 함수가 `intent.state` 값을 `Failed`로 반환한 경우 전송됩니다.
+ **시간 초과** - Lambda 함수가 구성된 시간 초과 기간 내에 완료되지 않은 경우 전송됩니다.

![\[Lambda 함수 실행 후 메시지에 사용할 수 있는 옵션을 보여주는 순서도.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/conditional-code-hook.png)


**Lambda 대화 코드 후크**를 선택한 다음 **고급 옵션**을 선택하여 Lambda 함수 호출에 해당하는 응답에 대한 세 가지 옵션을 확인합니다. 값을 설정하고, 다음 단계를 구성하고, 각 응답에 해당하는 조건을 적용하여 대화 흐름을 설계할 수 있습니다. 조건이 없거나 명시적인 다음 단계가 없는 경우 Amazon Lex V2는 대화의 현재 상태를 기반으로 다음 단계를 결정합니다.

**고급 옵션** 페이지에서 Lambda 함수 호출을 활성화하거나 비활성화하도록 선택할 수도 있습니다. 함수가 활성화되면 Lambda 간접 호출과 함께 대화 코드 후크가 간접적으로 호출되고 Lambda 간접 호출 결과를 기반으로 성공, 실패 또는 시간 초과 메시지가 표시됩니다. 함수가 비활성화되면 Amazon Lex V2는 Lambda 함수를 실행하지 않고 대화 코드 후크가 성공한 것처럼 계속 진행합니다.

또한 이 메시지로 Lambda 함수를 간접적으로 호출할 때 Lambda 함수로 전송되는 간접 호출 레이블을 설정할 수 있습니다. 레이블을 사용하여 실행할 Lambda 함수 섹션을 식별할 수 있습니다.

**참고**  
2022년 8월 17일, Amazon Lex V2는 사용자와의 대화를 관리하는 방식에 대한 변경 사항을 발표했습니다. 이번 변경을 통해 사용자가 대화를 통해 이동하는 경로를 더 효과적으로 제어할 수 있게 되었습니다. 자세한 내용은 [Amazon Lex V2의 대화 흐름 변경 사항](understanding-new-flows.md) 단원을 참조하세요. 2022년 8월 17일 이전에 생성된 봇은 대화 코드 후크 메시지, 값 설정, 다음 단계 구성, 조건 추가를 지원하지 않습니다.

# 시각적 대화 빌더 사용
<a name="visual-conversation-builder"></a>

시각적 대화 빌더는 풍부한 시각적 환경 내에서 의도를 사용하여 대화 경로를 쉽게 설계하고 시각화할 수 있는 드래그 앤 드롭 방식의 대화 빌더입니다.

**시각적 대화 빌더에 액세스하려면**

1. Amazon Lex V2 콘솔에서 봇을 선택하고 왼쪽 탐색 창에서 **의도**를 선택합니다.

1. 다음 방법 중 하나로 의도 편집기로 이동합니다.
   + **의도** 섹션의 오른쪽 상단에서 **의도 추가**를 선택한 다음 빈 의도를 추가할지 아니면 기본 제공 의도를 추가할지 선택합니다.
   + **의도** 섹션에서 의도 이름을 선택합니다.

1. 의도 편집기에서 화면 하단 창의 **시각적 빌더**를 선택하여 시각적 대화 빌더에 액세스합니다.

1. 메뉴 의도 편집기 인터페이스로 돌아가려면 **편집기**를 선택합니다.

![\[시각적 대화 빌더를 사용한 샘플 대화 흐름.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/vcb-sample.png)


시각적 대화 빌더는 대화 흐름을 시각화하고 수정할 수 있는 기능을 갖춘 보다 직관적인 사용자 인터페이스를 제공합니다. 블록을 드래그 앤 드롭하여 기존 흐름을 확장하거나 대화 단계를 재정렬할 수 있습니다. Lambda 코드를 작성하지 않고도 복잡한 분기를 사용하여 대화 흐름을 개발할 수 있습니다.

이 변경은 Lambda의 다른 비즈니스 로직과 대화 흐름 설계를 분리하는 데 도움이 됩니다. 시각적 대화 빌더는 기존 의도 편집기와 함께 사용할 수 있으며 대화 흐름을 구축하는 데 사용할 수 있습니다. 하지만 좀 더 복잡한 대화 흐름에는 시각적 편집기 보기를 사용하는 것이 좋습니다.

의도를 저장하면 Amazon Lex V2에서 누락된 연결이 확인되면 의도를 자동으로 연결하거나, Amazon Lex V2가 연결을 제안하거나, 사용자가 직접 차단할 연결을 선택할 수 있습니다.


| Action | 예시 | 
| --- | --- | 
|  작업 영역에 블록 추가  |  ![\[작업 영역으로 블록 추가\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/vcb-addblock.gif)  | 
|  블록 간 연결 만들기  |  ![\[블록 간 연결 만들기\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/vcb-connectionblock.gif)  | 
|  블록에서 구성 패널 열기  |  ![\[블록의 구성 패널 열기\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/vcb-openpanelblock.gif)  | 
|  크기에 맞게 확대/축소  |  ![\[크기에 맞게 확대/축소\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/vcb-zoomtofit.gif)  | 
|  대화 흐름에서 블록 삭제  |  ![\[대화 흐름에서 블록 삭제\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/vcb-deleteblock.gif)  | 
|  작업 영역 자동 정리  |  ![\[작업 영역 자동 정리\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/vcb-autoclean.gif)  | 

**용어:**

**블록** – 대화 흐름의 기본 구성 단위입니다. 각 블록에는 대화의 다양한 사용 사례를 처리하는 특정 기능이 있습니다.

**포트** - 각 블록에는 한 블록을 다른 블록에 연결하는 데 사용할 수 있는 포트가 있습니다. 블록에는 입력 포트와 출력 포트가 포함될 수 있습니다. 각 출력 포트는 블록의 특정 기능 변화(예: 오류, 시간 초과 또는 성공)를 나타냅니다.

**엣지** – 엣지는 한 블록의 출력 포트와 다른 블록의 입력 포트를 연결하는 것입니다. 대화 흐름에서 분기의 일부입니다.

**대화 흐름** – 고객과의 의도 수준 상호 작용을 설명하는 엣지로 연결된 블록 세트입니다.

**블록**

블록은 대화 흐름 설계의 구성 요소입니다. 의도 시작부터 사용자 입력, 종료까지 의도 내의 다양한 상태를 나타냅니다.

블록 유형에 따라 각 블록에는 진입점과 하나 이상의 종료점이 있습니다. 대화가 종료점을 통해 진행될 때 각 종료점을 해당 메시지로 구성할 수 있습니다. 종료점이 여러 개 있는 블록의 경우 종료점은 노드에 해당하는 상태와 관련이 있습니다. 조건 노드의 경우 종료점은 다양한 조건을 나타냅니다.

각 블록에는 블록 오른쪽 상단의 **편집** 아이콘을 클릭하면 열리는 구성 패널이 있습니다. 구성 패널에는 각 블록에 맞게 구성할 수 있는 세부 필드가 있습니다.

봇 프롬프트와 메시지는 새 블록을 드래그하여 노드에서 직접 구성하거나 오른쪽 패널에서 블록의 다른 속성과 함께 수정할 수 있습니다.

**블록 유형** – 시각적 대화 빌더와 함께 사용할 수 있는 블록 유형은 다음과 같습니다.


| 블록 유형 | 블록 | 
| --- | --- | 
|  **시작** - 대화 흐름의 루트 또는 첫 번째 블록입니다. 봇이 초기 응답(의도가 인식되었다는 메시지)을 보낼 수 있도록 이 블록을 구성할 수도 있습니다. 자세한 내용은 [초기 응답](intent-initial.md) 섹션을 참조하세요.  |  ![\[시각적 대화 빌더의 시작 블록\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/vcb-start.png)  | 
|  **슬롯 값 가져오기** – 이 블록은 단일 슬롯에 대한 값을 유도하려고 합니다. 이 블록에는 슬롯 유도 프롬프트에 대한 고객 응답을 기다리는 설정이 있습니다. 자세한 내용은 [Slots](intent-slots.md) 섹션을 참조하세요.  |  ![\[시각적 대화 빌더의 슬롯 값 가져오기 블록\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/vcb-getslotvalue.png)  | 
|  **조건** – 이 블록에는 조건문이 포함되어 있습니다. 여기에는 최대 4개의 사용자 지정 분기(조건 포함)와 1개의 기본 분기가 포함됩니다. 자세한 내용은 [조건을 추가하여 대화 분기 설정](paths-branching.md) 섹션을 참조하세요.  |  ![\[시각적 대화 빌더의 조건 블록\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/vcb-condition.png)  | 
|  **대화 코드 후크** - 이 블록은 대화 Lambda 함수 호출을 처리합니다. 이 블록에는 Lambda 함수 성공, 실패 또는 시간 초과에 따른 봇 응답이 포함되어 있습니다. 자세한 내용은 [대화 코드 후크 간접 호출](paths-code-hook.md) 섹션을 참조하세요.  |  ![\[시각적 대화 빌더의 코드 후크 블록\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/vcb-codehook.png)  | 
|  **확인** – 이 블록은 의도를 충족하기 전에 고객을 쿼리합니다. 여기에는 확인 프롬프트에 예 또는 아니오로 답한 고객을 기반으로 한 봇 응답이 포함됩니다. 자세한 내용은 [확인](intent-confirm.md) 섹션을 참조하세요.  |  ![\[시각적 대화 빌더의 확인 블록\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/vcb-confirmation.png)  | 
|  **이행** – 이 블록은 일반적으로 슬롯 유도 후 의도 이행을 처리합니다. 이행이 성공하거나 실패할 경우 Lambda 함수를 호출하고 메시지로 응답하도록 구성할 수 있습니다. 자세한 내용은 [이행](intent-fulfillment.md) 섹션을 참조하세요.  |  ![\[시각적 대화 빌더의 이행 블록\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/vcb-fulfillment.png)  | 
|  **응답 종료** – 이 블록을 사용하면 봇이 대화를 종료하기 전에 메시지로 응답할 수 있습니다. 자세한 내용은 [종료 응답](intent-closing.md) 섹션을 참조하세요.  |  ![\[시각적 대화 빌더의 종료 블록\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/vcb-closing.png)  | 
|  **대화 종료** – 이 블록은 대화 흐름의 종료를 나타냅니다.  |  ![\[시각적 대화 빌더의 엔드 블록\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/vcb-end.png)  | 
|  **사용자 입력 대기** – 이 블록을 사용하여 고객의 입력을 캡처하고 발화에 따라 다른 의도로 전환할 수 있습니다.  |  ![\[시각적 대화 빌더의 대기 블록\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/vcb-wait.png)  | 
|  **의도로 이동** – 이 블록을 사용하여 새 의도로 이동하거나 해당 의도의 특정 슬롯을 직접 유도할 수 있습니다.  |  ![\[시각적 대화 빌더의 의도로 이동 블록\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/vcb-gotointent.png)  | 

**포트 유형**

모든 블록에는 상위 블록을 연결하는 데 사용되는 입력 포트 하나가 있습니다. 대화는 상위 블록의 출력 포트에서 특정 블록의 입력 포트로만 전달될 수 있습니다. 그러나 블록에는 0, 1 또는 여러 개의 출력 포트가 포함될 수 있습니다. 출력 포트가 없는 블록은 현재 의도(`GoToIntent`,`EndConversation`,`WaitForUserInput`)의 대화 흐름이 종료되었음을 의미합니다.

**의도 설계 규칙:**
+ 의도의 모든 흐름은 시작 블록에서 시작됩니다.
+ 각 종료점에 해당하는 메시지는 선택 사항입니다.
+ 구성 패널의 각 종료점에 해당하는 값을 설정하도록 블록을 구성할 수 있습니다.
+ 의도 내 단일 흐름에는 단일 시작, 확인, 이행 및 종료 블록만 존재할 수 있습니다. 여러 조건, 대화 코드 후크, 슬롯 값 가져오기, 대화 종료, 전송 및 사용자 입력 대기 블록이 존재할 수 있습니다.
+ 조건 블록은 조건 블록에 직접 연결할 수 없습니다. 대화 코드 후크에도 동일하게 적용됩니다.
+ 순환 흐름은 세 블록은 허용되지만 시작 의도로 수신 커넥터는 허용되지 않습니다.
+ 옵션 슬롯에는 수신 커넥터나 발신 연결이 없으며 주로 의도 유도 중에 존재하는 모든 데이터를 캡처하는 데 사용됩니다. 대화 경로의 일부인 다른 모든 슬롯은 필수 슬롯이어야 합니다.

블록:
+ 시작 블록에는 아웃바운드 엣지가 있어야 합니다.
+ 슬롯이 필요한 경우 모든 슬롯 값 가져오기 블록에는 성공 포트의 아웃바운드 엣지가 있어야 합니다.
+ 블록이 활성 상태인 경우 모든 조건 블록에는 각 분기로부터 나가는 엣지가 있어야 합니다.
+ 조건 블록에는 상위가 두 개 이상 있을 수 없습니다.
+ 활성 조건 블록에는 수신 엣지가 있어야 합니다.
+ 모든 활성 코드 후크 블록에는 각 포트의 아웃바운드 엣지(성공, 실패 및 시간 초과)가 있어야 합니다.
+ 활성 코드 후크 블록에는 수신 엣지가 있어야 합니다.
+ 활성 확인 블록에는 수신 엣지가 있어야 합니다.
+ 활성 이행 블록에는 수신 엣지가 있어야 합니다.
+ 활성 종료 블록에는 수신 엣지가 있어야 합니다.
+ 조건 블록에는 기본이 아닌 분기가 하나 이상 있어야 합니다.
+ 의도로 이동 블록에는 의도가 지정되어 있어야 합니다.

엣지:
+ 조건 블록은 다른 조건 블록에 연결할 수 없습니다.
+ 코드 후크 블록은 다른 코드 후크 블록에 연결할 수 없습니다.
+ 조건 블록은 0개 또는 1개의 코드 후크 블록에만 연결할 수 있습니다.
+ 연결(코드 후크 -> 조건 -> 코드 후크)이 유효하지 않습니다.
+ 이행 블록은 하위 블록과 동일한 코드 후크 블록을 포함할 수 없습니다.
+ 이행 블록의 하위 블록인 조건 블록에는 코드 후크 블록 하위가 포함될 수 없습니다.
+ 종료 블록에는 하위 블록과 동일한 코드 후크 블록이 포함될 수 없습니다.
+ 종료 블록의 하위 블록인 조건 블록은 코드 후크 블록의 하위 블록을 가질 수 없습니다.
+ 시작, 확인 또는 슬롯 값 가져오기 블록은 종속성 체인에 코드 후크 블록을 두 개 이상 포함할 수 없습니다.

**참고**  
2022년 8월 17일, Amazon Lex V2는 사용자와의 대화를 관리하는 방식에 대한 변경 사항을 발표했습니다. 이번 변경을 통해 사용자가 대화를 통해 이동하는 경로를 더 효과적으로 제어할 수 있게 되었습니다. 자세한 내용은 [Amazon Lex V2의 대화 흐름 변경 사항](understanding-new-flows.md) 단원을 참조하세요. 2022년 8월 17일 이전에 생성된 봇은 대화 코드 후크 메시지, 값 설정, 다음 단계 구성, 조건 추가를 지원하지 않습니다.

# 기본 제공 의도
<a name="built-in-intents"></a>

일반적인 작업에 표준 기본 제공 의도 라이브러리를 사용할 수 있습니다. 기본 제공 의도에서 의도를 생성하려면, 콘솔에서 기본 제공 의도를 선택한 후 해당 기본 제공 의도에 새 이름을 지정합니다. 새 의도에는 샘플 표현 등 기본 의도의 구성이 포함되어 있습니다.

현재 구현에서는 다음 작업을 수행할 수 없습니다.
+ 기본 의도에서 샘플 표현 추가 또는 제거
+ 기본 제공 의도의 슬롯 구성

**봇에 기본 제공 의도를 추가하려면**

1. AWS Management Console에 로그인하여 [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)에서 Amazon Lex 콘솔을 엽니다.

1. 기본 제공 의도를 추가할 봇을 선택합니다.

1. 왼쪽 메뉴에서 언어를 선택한 다음 **의도**를 선택합니다.

1. **의도 추가**를 선택한 다음 **기본 제공 의도 사용**을 선택합니다.

1. **기본 제공 의도**에서 사용할 의도를 선택합니다.

1. 의도에 이름을 지정한 다음 **추가**를 선택합니다.

1. 의도 편집기를 사용하여 봇에 필요한 의도를 구성하세요.

**Topics**
+ [AMAZON.BedrockAgentIntent](built-in-intent-bedrockagent.md)
+ [AMAZON.CancelIntent](built-in-intent-cancel.md)
+ [AMAZON.FallbackIntent](built-in-intent-fallback.md)
+ [AMAZON.HelpIntent](built-in-intent-help.md)
+ [AMAZON.KendraSearchIntent](built-in-intent-kendra-search.md)
+ [AMAZON.PauseIntent](built-in-intent-pause.md)
+ [AMAZON.QnAIntent](built-in-intent-qna.md)
+ [AMAZON.QnAIntent (multiple use support)](built-in-intent-qna-multi.md)
+ [AMAZON.QinConnectIntent](built-in-intent-qinconnect.md)
+ [AMAZON.RepeatIntent](built-in-intent-repeat.md)
+ [AMAZON.ResumeIntent](built-in-intent-resume.md)
+ [AMAZON.StartOverIntent](built-in-intent-start-over.md)
+ [AMAZON.StopIntent](built-in-intent-stop.md)

# AMAZON.BedrockAgentIntent
<a name="built-in-intent-bedrockagent"></a>

**참고**  
생성형 AI 기능을 활용하려면 먼저 다음 사전 조건을 충족해야 합니다.  
Amazon Bedrock 사용 요금에 대한 자세한 내용은 [Amazon Bedrock 요금](https://aws.amazon.com/bedrock/pricing/)을 참조하세요.
봇 로캘에 맞는 생성형 AI 기능을 켭니다. 이렇게 하려면 [생성형 AI를 사용하여 Lex V2 봇 생성 및 성능 최적화](generative-features.md) 단원의 절차를 따르세요.

의도에 정의된 Amazon Bedrock 에이전트를 활성화하여 고객 요청에 응답하고 에이전트 워크플로를 활성화하여 정의된 작업을 달성합니다. 이 기능은 모든 Amazon Lex V2 지원 로캘과 Amazon Lex V2 및 Amazon Bedrock 에이전트가 모두 있는 모든 상용 리전에서 사용할 수 있습니다.

이 의도가 `FallbackIntent`를 재정의하는 경우 발화가 봇에 있는 다른 의도로 분류되지 않으면 의도가 활성화되고, 그렇지 않으면 발화가 이 의도로 분류될 때만 활성화됩니다. 슬롯 값을 도출할 때 누락된 표현에 대해서는 이 의도가 활성화되지 않는다는 점에 유의하세요.

Amazon Lex V2 봇이 인식하면 `AMAZON.BedrockAgentIntent`는 정의된 `BedrockAgent` 또는 `BedrockKnowledgeBase`를 활성화하여 고객에게 응답합니다. Amazon Bedrock 에이전트를 사용하는 경우 Amazon Bedrock 에이전트에서 대화가 `FINISH`로 표시된 것으로 확인될 때까지 대화가 `BedrockAgentIntent`에 유지되고 사용자 요청이 에이전트에 릴레이됩니다. 그 후에만 Amazon Lex V2는 대화를 제어하고 `AMAZON.BedrockAgentIntent`에 정의된 다음 단계를 준수합니다.

Amazon Bedrock 에이전트 및 지식 기반을 사용하여 고객 질문에 응답하고 자세한 응답을 제공합니다.

**주의**  
샘플 발화 없는 `AMAZON.BedrockAgentIntent`, 샘플 발화 없는 `AMAZON.QnAIntent` 및 동일한 봇 로캘의 `AMAZON.KendraSearchIntent`는 사용할 수 없습니다.

이 의도를 선택하는 경우에는 다음 필드를 구성한 다음 추가를 선택하여 의도를 추가합니다.
+ Amazon Bedrock 에이전트 ID - Amazon Bedrock 에이전트의 식별자입니다. 사용할 Bedrock 에이전트를 선택합니다.
+ Amazon Bedrock 에이전트 별칭 ID - Amazon Bedrock 에이전트의 별칭 식별자입니다.

**중요**  
Amazon Lex V2와 함께 사용할 Amazon Bedrock 에이전트를 생성할 때 **추가 설정** 아래의 **사용자 입력**이 `ENABLED`인지 확인합니다. 이 설정은 에이전트가 확인 또는 후속 질문을 할 수 있도록 허용하고 Amazon Lex V2가 에이전트에 다시 위임하여 해당 작업을 완료할 수 있도록 하는 데 매우 중요합니다.

(선택 사항) 다음 옵션을 사용하여 BedrockAgentIntent를 추가할 수도 있습니다.
+ Amazon Bedrock 모델 - 이 의도에 사용할 공급자 및 파운데이션 모델을 선택합니다. 현재 일부 Anthropic Claude 모델이 지원됩니다.
+ Amazon Bedrock 지식 기반 - 이 옵션을 선택하는 경우 Amazon Bedrock 지식 기반의 ID를 지정합니다. 콘솔에서 Amazon Bedrock 지식 기반의 세부 정보 페이지를 확인하거나 `GetKnowledgeBase` 요청을 보내서 ID를 찾을 수 있습니다.

BedrockAgentIntent의 응답은 아래와 같이 세션 및 요청 속성에 저장됩니다.
+ `x-amz-lex:bedrock-agent-search-response` - 질문 또는 발화에 대한 Amazon Bedrock 에이전트의 응답입니다.
+ `x-amz-lex:bedrock-knowledge-base-search-response-source` - Amazon Bedrock 지식 기반 구성을 사용하는 경우 응답을 생성하는 데 사용되는 문서 또는 문서 목록을 가리킵니다.
+ `x-amz-lex:bedrock-agent-action-group-invocation-input` - 에이전트 작업 그룹에서 수집한 입력 값을 포함하는 객체입니다. 에이전트 작업 그룹에 대한 자세한 내용은 ActionGroupInvocationInput을 참조하세요.
+ `x-amz-lex:bedrock-agent-knowledge-base-lookup-input` - Amazon Bedrock 지식 기반 조회 관련 세부 정보가 포함된 객체입니다.
+ `x-amz-lex:bedrock-agent-agent-collaborator-details` - 다중 에이전트 협업 간접 호출의 일부로 간접 호출된 하위 에이전트의 입력 및 출력에 대한 세부 정보가 포함된 객체입니다.

자세한 내용은 [ Amazon Lex에서 BedrockAgentIntent를 사용하여 Bedrock 에이전트 사용을 참조하세요](https://docs.aws.amazon.com/lexv2/latest/dg/bedrock-agent-intent.html).

# AMAZON.CancelIntent
<a name="built-in-intent-cancel"></a>

사용자가 현재 상호 작용을 취소하기를 원한다는 것을 나타내는 단어와 문구에 응답합니다. 애플리케이션은 이 의도를 사용하여 사용자와의 상호작용을 종료하기 전에 슬롯 유형 값 및 기타 속성을 제거할 수 있습니다.

공통 표현:
+ 취소
+ 신경 쓰지 마
+ 잊어버려

# AMAZON.FallbackIntent
<a name="built-in-intent-fallback"></a>

사용자의 의도 입력이 봇의 예상과 다를 경우 Amazon Lex V2가 *폴백 의도*를 간접적으로 호출하도록 구성할 수 있습니다. 예를 들어 사용자 입력 “캔디를 주문하고 싶어”가 봇의 `OrderFlowers` 의도와 맞지 않는 경우 Amazon Lex V2는 응답 처리를 위해 폴백 의도를 간접적으로 호출합니다.

[콘솔을 사용하여 봇을 생성하거나 CreateBotLocale](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateBotLocale.html) 작업을 사용하여 봇에 로캘을 추가하면 내장된 `AMAZON.FallbackIntent` 의도 유형이 봇에 자동으로 추가됩니다.

폴백 의도 간접 호출은 두 단계로 진행됩니다. 첫 번째 단계에서 폴백 의도는 사용자의 입력을 기반으로 매칭됩니다. 폴백 의도가 일치할 경우 봇이 작동하는 방식은 프롬프트에 설정된 재시도 수에 따라 다릅니다.

Amazon Lex V2가 폴백 의도와 일치하는 경우는 다음과 같습니다.
+ 의도에 대한 사용자 입력이 봇이 예상한 입력과 같지 않습니다.
+ 음성 입력에 노이즈가 있거나, 텍스트 입력이 단어로 인식되지 않습니다.
+ 사용자 입력이 모호하여 Amazon Lex V2에서 간접적으로 호출할 의도를 판단할 수 없습니다.

폴백 의도가 간접적으로 호출되는 시점은 다음과 같습니다.
+ 설정된 시도 횟수를 넘긴 후에도 의도가 사용자 입력을 슬롯 값으로 인식하지 않는 경우
+ 설정된 시도 횟수를 넘긴 후에도 의도가 사용자 입력을 확인 프롬프트에 대한 응답으로 인식하지 않는 경우

다음은 폴백 의도에 추가할 수 없습니다.
+ 표현
+ Slots
+ 확인 프롬프트

## 폴백 의도에 Lambda 함수 사용
<a name="invoke-fallback"></a>

폴백 의도가 간접적으로 호출되면 응답은 [CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html) 작업에 대한 `fulfillmentCodeHook` 파라미터 설정에 따라 달라집니다. 봇은 다음 중 하나를 수행합니다.
+ 의도 정보를 클라이언트 애플리케이션에 반환합니다.
+ 별칭의 검증 및 이행 Lambda 함수를 직접 호출합니다. 세션에 설정된 세션 변수로 함수를 직접적으로 호출합니다.

폴백 의도가 간접적으로 호출될 때 응답을 설정하는 작업에 대한 자세한 내용은 [CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html) 작업의 `fulfillmentCodeHook` 파라미터를 참조하세요.

폴백 의도에서 이행 Lambda 함수를 사용하는 경우에는 이 함수로 다른 의도를 직접적으로 호출할 수 있습니다. 회신 번호를 수집하거나 고객 서비스 담당자와의 세션을 개설하는 사용자와 일종의 커뮤니케이션을 수행할 수도 있습니다.

세션이 동일하면 폴백 의도는 여러 번 간접적으로 호출할 수 있습니다. 예를 들어 Lambda 함수가 `ElicitIntent` 대화 작업을 사용하여 사용자에게 다른 의도를 묻는 프롬프트를 표시한다고 해 보겠습니다. Amazon Lex V2가 설정된 시도 횟수 이후에 사용자의 의도를 추론할 수 없다면 폴백 의도를 다시 간접적으로 호출합니다. 또한 사용자가 구성된 시도 횟수 후 올바른 슬롯 값으로 응답하지 않을 때도 폴백 의도를 간접적으로 호출합니다.

세션 변수를 사용하여 폴백 의도를 직접적으로 호출하는 횟수를 추적하도록 Lambda 함수를 구성할 수 있습니다. Lambda 함수 는 Lambda 함수 에 설정한 임곗값보다 더 많이 직접적으로 호출될 경우 다른 작업을 수행할 수 있습니다. 세션 변수에 대한 자세한 내용은 [Lex V2 봇의 세션 특성 설정](context-mgmt-session-attribs.md) 단원을 참조하세요.

# AMAZON.HelpIntent
<a name="built-in-intent-help"></a>

사용자가 봇과 상호작용하는 동안 도움이 필요함을 나타내는 단어나 문구에 응답합니다. 이 의도가 간접적으로 호출되면 Lambda 함수 또는 애플리케이션을 구성하여 봇 기능에 대한 정보를 제공하고, 도움이 필요한 영역에 대한 후속 질문을 하거나, 상담원에게 상호 작용을 넘겨줄 수 있습니다.

공통 표현:
+ 도움
+ 도와줘
+ 나 좀 도와줄래?

# AMAZON.KendraSearchIntent
<a name="built-in-intent-kendra-search"></a>

Amazon Kendra 로 인덱싱된 문서를 검색하려면 `AMAZON.KendraSearchIntent` 의도를 사용합니다. Amazon Lex V2가 사용자와의 대화에서 다음 작업을 결정할 수 없으면 검색 의도가 트리거됩니다.

`AMAZON.KendraSearchIntent`는 영어(미국)(en-US) 및 미국 동부(버지니아 북부), 미국 서부(오리건) 및 유럽(아일랜드) 리전만 사용 가능합니다.

Amazon Kendra는 PDF 문서 또는 Microsoft Word 파일과 같은 자연어 문서를 인덱싱하는 기계 학습 기반 검색 서비스입니다. 인덱싱된 문서를 검색하고 질문에 대해 다음 유형의 응답을 반환할 수 있습니다.
+ 대답 
+ 질문에 대한 답이 될 수 있는 FAQ 항목
+ 질문과 관련된 문서

`AMAZON.KendraSearchIntent` 사용 예는 [예제: Amazon Kendra 인덱스에 대한 FAQ 봇 생성](faq-bot-kendra-search.md) 단원을 참조하세요.

봇에 `AMAZON.KendraSearchIntent` 의도를 구성하면 Amazon Lex V2가 의도에 대한 사용자 발화를 파악할 수 없을 때마다 이 의도를 직접적으로 호출합니다. Amazon Kendra에서 응답이 없으면 봇에 구성된 대로 대화가 계속됩니다.

**참고**  
 Amazon Lex V2는 현재 슬롯 유도 중 `AMAZON.KendraSearchIntent`를 지원하지 않습니다. Amazon Lex V2가 슬롯에 대한 사용자 발화를 확인할 수 없는 경우 `AMAZON.FallbackIntent`를 직접적으로 호출합니다.

동일한 봇에서 `AMAZON.KendraSearchIntent`를 `AMAZON.FallbackIntent`와 함께 사용하는 경우 Amazon Lex V2는 다음과 같이 의도를 사용합니다

1. Amazon Lex V2는 `AMAZON.KendraSearchIntent`를 직접적으로 호출합니다. 이 의도는 Amazon Kendra `Query` 작업을 직접적으로 호출합니다.

1. Amazon Kendra에서 응답을 반환하면 Amazon Lex V2가 사용자에게 결과를 표시합니다.

1. Amazon Kendra에서 응답이 없으면 Amazon Lex V2가 사용자에게 다시 메시지를 표시합니다. 다음 작업은 사용자의 응답에 따라 달라집니다.
   + 사용자의 응답에 슬롯 값을 채우거나 의도를 확인하는 것과 같이 Amazon Lex V2에서 인식하는 표현이 포함된 경우 봇에 구성된 대로 사용자와의 대화가 진행됩니다.
   + 사용자의 응답에 Amazon Lex V2에서 인식하는 표현이 포함되어 있지 않으면 Amazon Lex V2가 새로운 `Query` 작업을 직접적으로 호출합니다.

1. 구성된 재시도 횟수 이후에 응답이 없으면 Amazon Lex V2가 `AMAZON.FallbackIntent`를 직접적으로 호출하여 사용자와의 대화를 종료합니다.

`AMAZON.KendraSearchIntent`를 사용하여 Amazon Kendra 에 요청을 하는 방법에는 다음 세 가지가 있습니다.
+ 의도 검색이 대신 요청하도록 하세요. Amazon Lex V2는 사용자의 말을 검색 문자열로 사용하여 Amazon Kendra 를 직접적으로 호출합니다. 의도를 생성할 때 Amazon Kendra에서 반환되는 응답 수를 제한하는 쿼리 필터 문자열을 정의할 수 있습니다. Amazon Lex V2는 쿼리 요청에서 필터를 사용합니다.
+ Lambda 함수를 사용하여 요청에 추가 쿼리 파라미터 추가하세요. `delegate` 대화 작업에 Amazon Kendra 쿼리 파라미터가 포함된 `kendraQueryFilterString` 필드를 추가합니다. Lambda 함수 를 사용하여 요청에 쿼리 파라미터를 추가하면 해당 파라미터가 의도를 생성할 때 정의한 쿼리 필터보다 우선 적용됩니다.
+ Lambda 함수를 사용하여 새 쿼리를 생성하세요. Amazon Lex V2가 보내는 전체 Amazon Kendra 쿼리 요청을 생성할 수 있습니다. `delegate` 대화 작업의 `kendraQueryRequestPayload` 필드에 쿼리를 지정합니다. `kendraQueryRequestPayload` 필드가 `kendraQueryFilterString` 필드보다 우선 적용됩니다.

봇을 생성할 때 `queryFilterString` 파라미터를 지정하거나 대화 Lambda 함수에서 `delegate` 작업을 직접적으로 호출할 때 `kendraQueryFilterString` 필드를 지정하려면 Amazon Kendra 쿼리에 대한 속성 필터로 사용되는 문자열을 지정합니다. 문자열이 유효한 속성 필터가 아닌 경우 런타임에 `InvalidBotConfigException` 예외가 발생합니다. 속성 필터에 대한 자세한 내용은 *Amazon Kendra 개발자 안내서*의 [문서 속성을 사용하여 쿼리 필터링](https://docs.aws.amazon.com/kendra/latest/dg/filtering.html#search-filtering)을 참조하세요.

Amazon Lex V2가 Amazon Kendra 에 보내는 쿼리를 제어하려면 Lambda 함수 의 `kendraQueryRequestPayload` 필드에 쿼리를 지정합니다. 쿼리가 유효하지 않으면 Amazon Lex V2에서 `InvalidLambdaResponseException` 예외를 반환합니다. 자세한 내용은 *Amazon Kendra 개발자 안내서*의 [쿼리 작업](https://docs.aws.amazon.com/kendra/latest/dg/API_Query.html)을 참조하세요.

`AMAZON.KendraSearchIntent` 사용 방법의 예는 [예제: Amazon Kendra 인덱스에 대한 FAQ 봇 생성](faq-bot-kendra-search.md) 단원을 참조하세요.

## Amazon Kendra 검색에 사용되는 IAM 정책
<a name="kendra-search-iam"></a>

`AMAZON.KendraSearchIntent` 의도를 사용하려면 Amazon Lex V2가 Amazon Kendra `Query` 의도를 호출할 권한이 있는 런타임 역할을 수임할 수 있도록 하는 AWS Identity and Access Management(IAM) 정책을 제공하는 역할을 사용해야 합니다. V2 사용하는 IAM 설정은 Amazon Lex V2 콘솔`AMAZON.KendraSearchIntent`을 사용하여를 생성하는지 아니면 AWS SDK 또는 AWS Command Line Interface (AWS CLI)를 사용하여 생성하는지에 따라 달라집니다. 콘솔을 사용하는 경우 Amazon Lex V2 서비스 연결 역할에 Amazon Kendra 호출 권한을 추가하거나, Amazon Kendra `Query` 작업 직접 호출을 위한 전용 역할을 사용할 수 있습니다. AWS CLI 또는 SDK를 사용하여 의도를 생성할 때는 `Query` 작업을 직접적으로 호출하기 위한 역할을 사용해야 합니다.

### 권한 연결
<a name="kendra-iam-attach"></a>

Amazon Kendra 콘솔을 사용하여 `Query` 작업에 액세스할 수 있는 권한을 기본 Amazon Lex V2 서비스 연결 역할에 연결할 수 있습니다. 서비스 연결 역할에 권한을 연결하면 Amazon Kendra 인덱스에 연결하기 위한 전용 런타임 역할을 생성하고 관리할 필요가 없습니다.

Amazon Lex V2 콘솔에 액세스하는 데 사용하는 사용자, 역할 또는 그룹에는 역할 정책을 관리할 수 있는 권한이 있어야 합니다. 콘솔 액세스 역할에 다음 IAM 정책을 연결합니다. 이러한 권한을 부여하면 해당 역할이 기존 서비스 연결 역할 정책을 변경할 수 있는 권한을 갖게 됩니다.

------
#### [ JSON ]

****  

```
{
"Version":"2012-10-17",		 	 	 
"Statement": [
    {
        "Effect": "Allow",
        "Action": [
            "iam:AttachRolePolicy",
            "iam:PutRolePolicy",
            "iam:GetRolePolicy"
        ],
        "Resource": "arn:aws:iam::*:role/aws-service-role/lexv2.amazonaws.com/AWSServiceRoleForLexBots*"
    },
    {
        "Effect": "Allow",
        "Action": "iam:ListRoles",
        "Resource": "*"
    }
]
}
```

------

### 역할 지정
<a name="kendra-iam-role"></a>

콘솔, AWS CLI 또는 API를 사용하여 Amazon Kendra `Query` 작업을 호출할 때 사용할 런타임 역할을 지정할 수 있습니다.

런타임 역할을 지정하는 데 사용하는 사용자, 역할 또는 그룹에는 `iam:PassRole` 권한이 있어야 합니다. 다음 정책은 권한을 정의합니다. `iam:AssociatedResourceArn` 및 `iam:PassedToService` 조건 컨텍스트 키를 사용해 권한 범위를 추가로 제한할 수 있습니다. 자세한 내용은 *AWS Identity and Access Management * [ and Access Management 사용 설명서의 IAM 및 AWS STS 조건 컨텍스트 키를 참조하세요](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html).

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "arn:aws:iam::111122223333:role/role"
        }
    ]
}
```

------

Amazon Lex V2가 Amazon Kendra를 직접적으로 호출하는 데 사용하는 런타임 역할에는 `kendra:Query` 권한이 있어야 합니다. Amazon Kendra `Query` 작업을 직접적으로 호출할 수 있는 권한을 위해 기존 IAM 역할을 사용하는 경우 역할에 다음 정책이 연결되어 있어야 합니다.

IAM 콘솔, IAM API 또는 AWS CLI를 사용하여 정책을 생성하고 역할에 연결할 수 있습니다. 여기에 나온 지침에서는 AWS CLI를 사용하여 역할과 정책을 생성합니다.

**참고**  
다음 코드는 Linux 및 MacOS 용으로 형식이 지정됩니다. Windows의 경우 Linux 줄 연속 문자(\$1)를 캐럿(^)으로 바꿉니다.

**역할에 쿼리 작업 권한을 추가하려면**

1. 현재 디렉터리에 **KendraQueryPolicy.json**이라는 문서를 만들고 다음 코드를 추가한 다음 저장합니다.

1. AWS CLI에서 다음 명령을 실행하여 Amazon Kendra `Query` 작업을 실행하기 위한 IAM 정책을 생성합니다.

   ```
   aws iam create-policy \
   --policy-name query-policy-name \
   --policy-document file://KendraQueryPolicy.json
   ```

1. `Query` 작업을 직접적으로 호출하는 데 사용하는 IAM 역할에 정책을 연결합니다.

   ```
   aws iam attach-role-policy \
   --policy-arn arn:aws:iam::account-id:policy/query-policy-name
   --role-name role-name
   ```

Amazon Lex V2 서비스 연결 역할을 업데이트하거나 봇에 `AMAZON.KendraSearchIntent`를 만들 때 생성한 역할을 사용하도록 선택할 수 있습니다. 다음 절차에서는 사용할 IAM 역할을 선택하는 방법을 보여 줍니다.

**AMAZON.KendraSearchIntent에 대한 런타임 역할을 지정하려면 다음을 수행합니다.**

1. AWS Management Console에 로그인하여 [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)에서 Amazon Lex 콘솔을 엽니다.

1. `AMAZON.KendraSearchIntent`를 추가할 봇을 선택합니다.

1. **의도** 옆에 있는 더하기(\$1) 기호를 선택합니다.

1. **의도 추가**에서 **기존 의도 검색**을 선택합니다.

1. **검색 의도**에 **AMAZON.KendraSearchIntent**를 입력한 다음 **추가**를 선택합니다.

1. **기본 제공 의도 복사**에서 의도의 이름(예: **KendraSearchIntent**)을 입력한 다음 **추가**를 선택합니다.

1. **Amazon Kendra 쿼리** 섹션을 엽니다.

1. **IAM 역할**에서 다음 옵션 중 하나를 선택합니다.
   + 봇이 Amazon Kendra 인덱스를 쿼리할 수 있도록 Amazon Lex V2 서비스 연결 역할을 업데이트하려면 **Amazon Kendra 권한 추가**를 선택합니다.
   + Amazon Kendra `Query` 작업을 직접적으로 호출할 수 있는 권한이 있는 역할을 사용하려면 **기존 역할 사용**을 선택합니다.

## 요청 및 세션 속성을 필터로 사용
<a name="kendra-search-filter"></a>

Amazon Kendra의 응답을 현재 대화와 관련된 항목으로 필터링하려면 봇을 생성할 때 `queryFilterString` 파라미터를 추가하여 세션 및 요청 속성을 필터로 사용합니다. 의도를 생성할 때 속성의 자리 표시자를 지정하면 Amazon Lex V2가 Amazon Kendra를 직접적으로 호출하기 전에 해당 값을 대체합니다. 요청 속성에 대한 자세한 내용은 [Lex V2 봇의 요청 특성 설정](context-mgmt-request-attribs.md) 단원을 참조하세요. 세션 속성에 대한 자세한 내용은 [Lex V2 봇의 세션 특성 설정](context-mgmt-session-attribs.md) 단원을 참조하세요.

다음은 Amazon Kendra라는 요청 속성을 사용하여 쿼리를 필터링하는 `queryFilterString` 파라미터의 예제입니다.

```
"{"equalsTo": {"key": "City", "value": {"stringValue": "Seattle"}}}"
```

다음은 `"SourceURI"`이라는 세션 속성을 사용하여 Amazon Kendra 쿼리를 필터링하는 `queryFilterString` 파라미터의 예입니다.

```
"{"equalsTo": {"key": "SourceURI","value": {"stringValue": "[FileURL]"}}}"
```

다음은 `"DepartmentName"`이라는 요청 속성을 사용하여 Amazon Kendra 쿼리를 필터링하는 `queryFilterString` 파라미터의 예입니다.

```
"{"equalsTo": {"key": "Department","value": {"stringValue": "((DepartmentName))"}}}"
```

`AMAZON.KendraSearchInteng` 필터는 Amazon Kendra 검색 필터와 동일한 형식을 사용합니다. 자세한 내용은 *Amazon Kendra 개발자 안내서*의 [문서 속성을 사용하여 검색 결과 필터링](https://docs.aws.amazon.com/kendra/latest/dg/filtering.html#search-filtering)을 참조하세요.

`AMAZON.KendraSearchIntent`과 함께 사용되는 쿼리 필터의 문자열은 각 필터의 첫 글자에 소문자를 사용해야 합니다. 예를 들어, 다음은 `AMAZON.KendraSearchIntent`에 대한 유효한 쿼리 필터입니다.

```
{
"andAllFilters": [
    {
        "equalsTo": {
            "key": "City",
            "value": {
                "stringValue": "Seattle"
            }
        }
    },
    {
        "equalsTo": {
            "key": "State",
            "value": {
                "stringValue": "Washington"
            }
        }
    }
]
}
```

## 검색 응답 사용
<a name="kendra-search-response"></a>

Amazon Kendra는 검색에 대한 응답을 의도 `IntentClosingSetting` 문의 응답으로 반환합니다. Lambda 함수가 종료 응답 메시지를 생성하지 않는 한 의도에는 `closingResponse` 문이 있어야 합니다.

Amazon Kendra 에는 다섯 가지 유형의 응답이 있습니다.
+ 다음 두 가지 응답에는 Amazon Kendra 인덱스에 대해 FAQ를 설정해야 합니다. 자세한 내용은 [인덱스에 직접 질문 및 답변 추가](https://docs.aws.amazon.com/kendra/latest/dg/in-creating-faq.html)를 참조하세요.
  +  `x-amz-lex:kendra-search-response-question_answer-question-<N>` – 검색과 일치하는 FAQ 질문 
  +  `x-amz-lex:kendra-search-response-question_answer-answer-<N>` – 검색과 일치하는 FAQ 답변 
+ 다음 세 가지 응답에는 Amazon Kendra 인덱스에 대해 데이터 소스를 설정해야 합니다. 자세한 내용은 [데이터 소스 생성](https://docs.aws.amazon.com/kendra/latest/dg/data-source.html)을 참조하세요.
  + `x-amz-lex:kendra-search-response-document-<N>` – 표현 텍스트와 관련된 인덱스에 있는 문서의 발췌문.
  + `x-amz-lex:kendra-search-response-document-link-<N>` – 표현 텍스트와 관련된 인덱스에 있는 문서의 URL.
  + `x-amz-lex:kendra-search-response-answer-<N>` – 질문에 대한 답이 되는 인덱스에 있는 문서의 발췌문.

응답은 `request` 속성에서 반환됩니다. 각 속성에 1부터 5까지 번호가 매겨진 최대 5개의 응답이 있을 수 있습니다. 서비스 이름 변경에 대한 자세한 내용을 알아보려면 *Amazon Kendra 개발자 가이드*의 [응답 유형](https://docs.aws.amazon.com/kendra/latest/dg/response-types.html)을 참조하세요.

`closingResponse` 문에는 하나 이상의 메시지 그룹이 있어야 합니다. 각 메시지 그룹에는 하나 이상의 메시지가 포함됩니다. 각 메시지에는 Amazon Kendra의 응답에서 요청 속성으로 대체되는 하나 이상의 자리 표시자 변수가 포함될 수 있습니다. 메시지 그룹에는 해당 메시지의 모든 변수가 런타임 응답에서 요청 속성 값으로 대체되는 메시지가 하나 이상 있어야 합니다. 그렇지 않은 경우 자리 표시자 변수가 없는 메시지 하나가 그룹에 있어야 합니다. 요청 속성은 이중 괄호("((" "))")로 묶입니다. 다음 메시지 그룹 메시지는 Amazon Kendra의 모든 응답과 일치합니다.
+ "질문에 대한 FAQ를 찾았습니다: ((x-amz-lex:kendra-search-response-question\$1answer-question-1)), and the answer is ((x-amz-lex:kendra-search-response-question\$1answer-answer-1))"
+ "I found an excerpt from a helpful document: ((x-amz-lex:kendra-search-response-document-1))"
+ "질문에 대한 답변은 다음과 같습니다 ((x-amz-lex:kendra-search-response-answer-1))"

## Lambda 함수를 사용하여 요청 및 응답 관리
<a name="kendra-search-lambda"></a>

`AMAZON.KendraSearchIntent` 의도는 대화 코드 후크 및 이행 코드 후크를 사용하여 Amazon Kendra에 대한 요청과 응답을 관리할 수 있습니다. Amazon Kendra에 보내는 쿼리를 수정하려면 대화 코드 후크 Lambda 함수를 사용하고, 응답을 수정하려면 이행 코드 후크 Lambda 함수를 사용합니다.

### 대화 코드 후크를 사용하여 쿼리 생성
<a name="kendra-search-lambda-dialog"></a>

대화 코드 후크를 사용하여 Amazon Kendra에 보낼 쿼리를 생성할 수 있습니다. 대화 코드 후크 사용은 선택 사항입니다. 대화 코드 후크를 지정하지 않으면 Amazon Lex V2가 사용자 표현으로부터 쿼리를 구성하고 의도 구성 시 제공된(있는 경우) `queryFilterString`를 사용합니다.

Amazon Kendra에 대한 요청을 수정하기 위해 대화 코드 후크 응답에서 다음 두 필드를 사용할 수 있습니다.
+ `kendraQueryFilterString` – Amazon Kendra 요청에 대한 속성 필터를 지정하려면 이 문자열을 사용합니다. 인덱스에 정의된 인덱스 필드 중 하나를 사용하여 쿼리를 필터링할 수 있습니다. 필터 문자열의 구조는 *Amazon Kendra 개발자 안내서*의 [문서 속성을 사용하여 쿼리 필터링](https://docs.aws.amazon.com/kendra/latest/dg/filtering.html#search-filtering)을 참조하세요. 지정된 필터 문자열이 유효하지 않으면 `InvalidLambdaResponseException` 예외가 발생합니다. `kendraQueryFilterString` 문자열은 해당 의도에 구성된 `queryFilterString`에 지정되어 있는 모든 쿼리 문자열을 재정의합니다.
+ `kendraQueryRequestPayload` – Amazon Kendra 쿼리를 지정하려면 이 문자열을 사용합니다. 쿼리에서 Amazon Kendra의 모든 기능을 사용할 수 있습니다. 유효한 쿼리를 지정하지 않으면 `InvalidLambdaResponseException` 예외가 발생합니다. 자세한 정보는 *Amazon Kendra 개발자 안내서*의 [쿼리](https://docs.aws.amazon.com/kendra/latest/dg/API_Query.html)를 참조하세요.

필터 또는 쿼리 문자열을 생성한 후 응답 `dialogAction` 필드를 `delegate`로 설정하여 Amazon Lex V2에 응답을 보냅니다. Amazon Lex V2는 Amazon Kendr에 쿼리를 보낸 다음 이행 코드 후크에 쿼리 응답을 반환합니다.

### 응답에 이행 코드 후크 사용
<a name="kendra-search-lambda-fulfillment"></a>

Amazon Lex V2가 Amazon Kendra에 쿼리를 보내면 쿼리 응답이 `AMAZON.KendraSearchIntent` 이행 Lambda 함수로 반환됩니다. 코드 후크에 대한 입력 이벤트에는 Amazon Kendra의 전체 응답이 포함되어 있습니다. 쿼리 데이터는 Amazon Kendra `Query` 작업에서 반환된 것과 동일한 구조입니다. 자세한 정보는 *Amazon Kendra 개발자 안내서*의 [쿼리 응답 구문](https://docs.aws.amazon.com/kendra/latest/dg/API_Query.html#API_Query_ResponseSyntax)을 참조하세요.

이행 코드 후크는 선택 사항입니다. 이행 코드 후크가 존재하지 않거나 이행 코드 후크가 응답에 메시지를 반환하지 않는 경우 Amazon Lex V2는 응답에 `closingResponse` 문을 사용합니다.

# 예제: Amazon Kendra 인덱스에 대한 FAQ 봇 생성
<a name="faq-bot-kendra-search"></a>

이 예제에서는 Amazon Kendra 인덱스를 사용하여 사용자의 질문에 대한 답변을 제공하는 Amazon Lex V2 봇을 생성합니다. FAQ 봇은 사용자와의 대화를 관리합니다. `AMAZON.KendraSearchIntent` 의도를 사용하여 인덱스에 쿼리하고 사용자에게 응답을 제공합니다. Amazon Kendra 색인을 사용하여 FAQ 봇을 생성하는 방법을 요약하면 다음과 같습니다.

1. 고객이 봇으로부터 답변을 얻기 위해 상호 작용할 봇을 생성합니다.

1. 사용자 지정 의도를 생성합니다. `AMAZON.KendraSearchIntent` 및 `AMAZON.FallbackIntent`는 백업 의도이므로 봇에는 발화를 하나 이상 포함해야 하는 다른 의도가 하나 이상 필요합니다. 이 의도는 봇을 빌드하는 데 필요하지만 다른 방식으로는 사용되지 않습니다. 따라서 FAQ 봇에는 아래 이미지와 같이 최소 세 개의 의도가 포함됩니다.  
![\[세 가지 의도를 가진 Kendra FAQ 봇\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/kendra-faqbot/kendra-intents.png)

1. 봇에 `AMAZON.KendraSearchIntent` 의도를 추가하고 [Amazon Kendra 인덱스](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)와 함께 작동하도록 구성합니다.

1. 쿼리를 만들고 Amazon Kendra 인덱스의 결과가 쿼리에 응답하는 문서인지 확인하여 봇을 테스트합니다.

**사전 조건**

이 예제를 사용하기 전에 Amazon Kendra 인덱스를 생성해야 합니다. 자세한 내용은 *Amazon Kendra 개발자 안내서*의 [Amazon Kendra 콘솔로 시작하기](https://docs.aws.amazon.com/kendra/latest/dg/gs-console.html)를 참조하세요. 이 예제에서는 샘플데이터 세트(**샘플 AWS 설명서**)를 데이터 소스로 선택합니다.

**FAQ 봇을 생성하려면:**

1. AWS Management Console에 로그인하여 [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)에서 Amazon Lex 콘솔을 엽니다.

1. 탐색 창에서 **봇**을 선택합니다.

1. **봇 생성**을 선택합니다.

   1.  **생성 방법**으로는 **빈 봇 만들기**를 선택합니다.

   1.  **봇 구성** 섹션에서 봇의 용도를 나타내는 이름(예: **KendraTestBot**)과 설명(선택 사항)을 입력합니다. 이름은 계정에서 고유해야 합니다.

   1.  **IAM 권한** 섹션에서 **기본 Amazon Lex 권한을 사용하여 역할 생성**을 선택합니다. 그러면 Amazon Lex V2가 봇을 실행하는 데 필요한 권한이 있는 [AWS Identity and Access Management(IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) 역할이 생성됩니다.

   1.  **COPPA(Children's Online Privacy Protection Act, 어린이 온라인 사생활 보호법)** 섹션에서 **아니오**를 선택합니다.

   1.  **유휴 세션 제한 시간** 및 **고급 설정** 섹션에서 기본 설정을 그대로 두고 **다음**을 선택합니다.

   1.  이제 **봇에 언어 추가** 섹션으로 이동했습니다. **음성 상호 작용** 아래의 메뉴에서 **없음을 선택합니다. 이 애플리케이션은 텍스트 기반 애플리케이션입니다**. 나머지 필드의 기본 설정은 그대로 둡니다.

   1.  **완료**를 선택합니다. Amazon Lex V2는 봇과 **NewIntent**라는 기본 의도를 생성하고 이 의도를 구성할 수 있는 페이지로 이동합니다.

봇을 성공적으로 구축하려면 `AMAZON.FallbackIntent` 및 `AMAZON.KendraSearchIntent`와 분리된 의도를 하나 이상 생성해야 합니다. 이 의도는 Amazon Lex V2 봇을 빌드하는 데 필요하지만 FAQ 응답에는 사용되지 않습니다. 이 의도는 최소 한 개의 샘플 발화를 포함해야 하며, 해당 발언은 고객이 묻는 질문에 적용되지 않아야 합니다.

**필요한 의도를 생성하려면**

1.  **의도 세부 정보** 섹션에서 의도에 이름을 입력합니다(예: **RequiredIntent**).

1.  **샘플 발화** 섹션에서 **발화 추가** 옆의 상자에 발화(예: **Required utterance**)를 입력합니다. 그런 다음 **발화 추가**를 선택합니다.

1. **의도 저장**을 선택합니다.

Amazon Kendra 인덱스를 검색하기 위한 의도와 이를 통해 반환되어야 하는 응답 메시지를 생성합니다.

**AMAZON.KendraSearchIntent 의도 및 응답 메시지를 생성하려면**

1.  탐색 창에서 **의도 목록으로 돌아가기**를 선택하여 봇의 **의도** 페이지로 돌아갑니다. **의도 추가**를 선택하고 드롭다운 메뉴에서 **기본 제공 의도 사용**을 선택합니다.

1.  팝업 상자에서 **기본 제공 의도**에서 메뉴를 선택합니다. 검색창에 **AMAZON.KendraSearchIntent**를 입력한 다음 목록에서 선택합니다.

1.  의도에 **KendraSearchIntent**와 같은 이름을 지정합니다.

1.  **Amazon Kendra 인덱스** 드롭다운 메뉴에서 검색하려는 인덱스를 선택합니다. **사전 조건** 섹션에서 만든 인덱스를 사용할 수 있어야 합니다.

1.  **추가**를 선택합니다.

1. 의도 에디터에서 **이행** 섹션까지 아래로 스크롤하고 오른쪽 화살표를 선택하여 섹션을 확장한 다음, **이행 성공 시** 아래의 상자에 다음 메시지를 추가합니다.

   ```
   I found a link to a document that could help you: ((x-amz-lex:kendra-search-response-document-link-1)).
   ```  
![\[이행 응답 추가\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/kendra-faqbot/kendra-fulfillment-response.gif)

    Amazon Kendra 검색 응답에 대한 자세한 내용은 [검색 응답 사용](https://docs.aws.amazon.com/lexv2/latest/dg/built-in-intent-kendra-search.html#kendra-search-response)을 참조하세요.

1. **의도 저장**을 선택한 다음 **빌드**를 선택하여 봇을 빌드합니다. 봇이 준비되면 화면 상단의 배너가 녹색으로 바뀌고 성공 메시지가 표시됩니다.

마지막으로 콘솔 테스트 창을 사용하여 봇의 응답을 테스트합니다.

**FAQ 봇을 테스트하려면:**

1.  봇이 성공적으로 빌드되면 **테스트**를 선택합니다.

1.  콘솔 테스트 창에 **What is Amazon Kendra?**를 입력합니다. 봇이 링크로 응답하는지 확인합니다.

1.  `AMAZON.KendraSearchIntent` 구성에 대한 자세한 내용은 [https://docs.aws.amazon.com/lexv2/latest/dg/built-in-intent-kendra-search.html](https://docs.aws.amazon.com/lexv2/latest/dg/built-in-intent-kendra-search.html) 및 [KendraConfiguration](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_KendraConfiguration.html)을 참조하세요.

# AMAZON.PauseIntent
<a name="built-in-intent-pause"></a>

사용자가 봇과의 상호 작용을 일시 중지하여 나중에 다시 돌아올 수 있도록 하는 단어 및 구문에 응답합니다. Lambda 함수 또는 애플리케이션이 의도 데이터를 세션 변수에 저장하거나, 현재 의도를 재개할 때 [GetSession](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_GetSession.html) 작업을 사용하여 의도 데이터를 검색해야 합니다.

공통 발화:
+ 일시 중지
+ 일시 중지

# AMAZON.QnAIntent
<a name="built-in-intent-qna"></a>

**참고**  
생성형 AI 기능을 활용하려면 먼저 다음 사전 조건을 충족해야 합니다.  
Amazon Bedrock 사용 요금에 대한 자세한 내용은 [Amazon Bedrock 요금](https://aws.amazon.com/bedrock/pricing/)을 참조하세요.
봇 로캘에 맞는 생성형 AI 기능을 켭니다. 이렇게 하려면 [생성형 AI를 사용하여 Lex V2 봇 생성 및 성능 최적화](generative-features.md) 단원의 절차를 따르세요.

Amazon Bedrock FM을 사용하여 FAQ 답변을 검색하고 요약하여 고객 질문에 응답합니다. 이 의도는 표현이 봇에 존재하는 다른 어떤 의도로도 분류되지 않을 때 활성화됩니다. 슬롯 값을 도출할 때 누락된 표현에 대해서는 이 의도가 활성화되지 않는다는 점에 유의하세요. 인식되면 `AMAZON.QnAIntent`는 지정된 Amazon Bedrock 모델을 사용하여 구성된 Amazon Bedrock 지식 기반을 검색하고 고객 질문에 응답합니다.

**주의**  
동일한 봇 로캘에서 `AMAZON.QnAIntent`와 `AMAZON.KendraSearchIntent`를 사용할 수 없습니다.

다음과 같은 지식 스토어 옵션을 사용할 수 있습니다. 이미 지식 스토어를 만들고 그 안에 있는 문서를 인덱싱했어야 합니다.
+ OpenSearch 서비스 도메인 - 인덱싱된 문서를 포함합니다. 도메인을 만들려면 [Amazon OpenSearch Service 도메인 생성 및 관리](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/createupdatedomains.html)의 단계를 따르세요.
+ Amazon Kendra 인덱스 - 인덱싱된 FAQ 문서를 포함합니다. Amazon Kendra 인덱스를 만들려면 [인덱스 생성](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)의 단계를 따르세요.
+ Amazon Bedrock 지식 기반 - 인덱싱된 데이터 소스가 포함되어 있습니다. Amazon Bedrock 지식 기반을 설정하려면 [지식 기반 구축](https://docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base.html)의 단계를 따르세요.

이 의도를 선택하는 경우에는 다음 필드를 구성한 다음 **추가**를 선택하여 의도를 추가합니다.
+ **Bedrock 모델** - 이 의도에 사용할 제공업체 및 파운데이션 모델을 선택합니다. 사용 가능한 최신 모델과 사용 중단 일정을 확인하고 그에 따라 마이그레이션을 계획해야 합니다. 자세한 내용은 [모델 수명 주기](https://docs.aws.amazon.com/bedrock/latest/userguide/model-lifecycle.html#versions-for-eol) 섹션을 참조하세요.
+ **지식 스토어** - 고객 질문에 답하기 위해 모델에서 정보를 가져올 소스를 선택합니다. 다음 소스를 사용할 수 있습니다.
  + **OpenSearch** - 다음 필드를 구성합니다.
    + **도메인 엔드포인트** - 도메인에 대해 직접 만들었거나 도메인 생성 후 제공된 도메인 엔드포인트를 입력합니다.
    + **인덱스 이름** - 검색할 인덱스를 입력합니다. 자세한 정보는 [Amazon OpenSearch Service에서 데이터 인덱싱](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/indexing.html)을 참조하세요.
    + 고객에게 응답을 반환하는 방법을 선택합니다.
      + **정확한 응답** - 이 옵션을 사용 설정하면 응답 필드의 값이 봇 응답에 그대로 사용됩니다. 구성된 Amazon Bedrock 파운데이 모델을 사용하여 콘텐츠 합성이나 요약 없이 정확한 답변 콘텐츠를 그대로 선택합니다. OpenSearch 데이터베이스에 구성된 질문 및 답변 필드의 이름을 지정합니다.
      + **필드 포함** - 지정한 필드를 사용하여 모델에서 생성된 답변을 반환합니다. OpenSearch 데이터베이스에 구성된 필드의 이름을 최대 5개까지 지정합니다. 세미콜론(;)을 사용하여 필드를 구분합니다.
  + **Amazon Kendra** - 다음 필드를 구성합니다.
    + **Amazon Kendra 인덱스** - 봇이 검색할 Amazon Kendra 인덱스를 선택합니다.
    + **Amazon Kendra 필터** - 필터를 만들려면 이 확인란을 선택합니다. Amazon Kendra 검색 필터 JSON 형식에 대한 자세한 내용은 [문서 속성을 사용하여 검색 결과 필터링](https://docs.aws.amazon.com/kendra/latest/dg/filtering.html#search-filtering)을 참조하세요.
    + **정확한 응답** - 봇이 Amazon Kendra에서 반환한 정확한 응답을 반환하도록 하려면 이 확인란을 선택합니다. 그러지 않으면 선택한 Amazon Bedrock 모델이 결과를 기반으로 응답을 생성합니다.
**참고**  
이 기능을 사용하려면 먼저 인덱스에 [자주 묻는 질문(FAQ) 추가](https://docs.aws.amazon.com/kendra/latest/dg/in-creating-faq.html)의 단계에 따라 인덱스에 FAQ 질문을 추가해야 합니다.
  + **Amazon Bedrock 지식 기반** - 이 옵션을 선택하는 경우 Amazon Bedrock 지식 기반의 ID를 지정합니다. 콘솔에서 Amazon Bedrock 지식 기반의 세부 정보 페이지를 확인하거나 [GetKnowledgeBase](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetKnowledgeBase.html) 요청을 보내서 ID를 찾을 수 있습니다.
    + **정확한 응답** - 이 옵션을 사용 설정하면 응답 필드의 값이 봇 응답에 그대로 사용됩니다. 구성된 Amazon Bedrock 파운데이 모델을 사용하여 콘텐츠 합성이나 요약 없이 정확한 답변 콘텐츠를 그대로 선택합니다. Amazon Bedrock 지식 기반에 정확한 응답을 사용하려면 다음을 수행해야 합니다.
      + 최종 사용자에게 반환해야 하는 정확한 응답을 포함하는 응답 필드가 포함된 각 파일을 사용하여 개별 JSON 파일을 생성합니다.
      + Bedrock 지식 기반에서 해당 문서를 인덱싱할 때 **청킹 전략**을 **청킹 없음**으로 선택합니다.
      + Amazon Lex V2의 응답 필드를 Bedrock 지식 기반의 응답 필드로 정의합니다.

QnAIntent의 응답은 아래와 같이 요청 속성에 저장됩니다.
+ `x-amz-lex:qnA-search-response` - 질문이나 표현에 대한 QnAIntent의 응답입니다.
+ `x-amz-lex:qnA-search-response-source` - 응답을 생성하는 데 사용된 문서 또는 문서 목록을 가리킵니다.
+ `x-amz-lex:qna-additional-context` - QnAIntent가 응답을 생성하는 데 사용하는 추가 컨텍스트입니다.

**추가 모델 구성**

AMAZON.QnAIntent가 간접적으로 호출되면 지침과 컨텍스트를 사용자 쿼리와 결합하여 응답 생성을 위해 모델로 전송되는 프롬프트를 구성하는 기본 프롬프트 템플릿을 사용합니다. 사용자 지정 프롬프트를 제공하거나 요구 사항에 맞게 기본 프롬프트를 업데이트할 수도 있습니다.

다음과 같은 도구를 사용하여 프롬프트 템플릿을 엔지니어링할 수 있습니다.

**프롬프트 자리 표시자** - Amazon Bedrock용 AMAZON.QnAIntent에서 미리 정의된 변수로, Bedrock 직접 호출 동안 런타임에 동적으로 채워집니다. 시스템 프롬프트에서 해당 자리 표시자는 `$` 기호로 둘러싸여 있습니다. 다음 목록은 사용할 수 있는 자리 표시자를 설명합니다.


| 변수 | 대체 | 모델 | 필수 | 
| --- | --- | --- | --- | 
| \$1query\$1results\$1 | 지식 스토어에서 사용자 쿼리에 대해 검색된 결과 | 선택한 Bedrock 모델 | 예 | 
| \$1output\$1instruction\$1 | 응답 생성 및 인용 형식 지정에 대한 기본 지침입니다. 모델에 따라 다릅니다. 자체 서식 지정 지침을 정의할 경우 이 자리 표시자를 제거하는 것이 좋습니다. | 선택한 Bedrock 모델 | 아니요 | 
| \$1additional\$1context\$1 | QnAIntent가 응답을 생성하는 데 사용하는 추가 컨텍스트 | 선택한 Bedrock 모델 | 아니요 | 
| \$1locale\$1 | 봇이 고객 쿼리에 응답할 언어 | 선택한 Bedrock 모델 | 아니요 | 

다음은 사용 중인 **기본 프롬프트**입니다.

```
$query_results$

$additional_context$

Please only follow the instructions in <instruction> tags below.
<instruction>
Given the conversation history, <additional_context> and <Context>:
(1) first, identify the user query intent and classify it as one of the categories: FAQ_QUERY, OTHER_QUERY, GIBBERISH, GREETINGS, AFFIRMATION, CHITCHAT, or MISC;
(2) second, if the intent is FAQ_QUERY, predict the most relevant grounding passage(s) by providing the passage id(s) or output CANNOTANSWER;
(3) then, generate a concise, to-the-point FAQ-style response in $locale$ locale ONLY USING the grounding content in <Context> and <additional_context>; or output CANNOTANSWER if the user query/request cannot be directly answered with the grounding content. DO NOT mention about the grounding passages such as ids or other meta data; do not create new content not presented in <Context>. Do NOT respond to query that is ill-intented or off-topic;
(4) lastly, provide the confidence level of the above prediction as LOW, MID or HIGH.
</instruction>

$output_instruction$
```

**\$1output\$1instruction\$1**은 다음으로 대체됩니다.

```
Give your final response in the following form:
<answer>
<intent>FAQ_QUERY or OTHER_QUERY or GIBBERISH or GREETINGS or AFFIRMATION or CHITCHAT or MISC</intent>
<text>a concise FAQ-style response or CANNOTANSWER</text>
<passage_id>passage_id or CANNOTANSWER</passage_id>
<confidence>LOW or MID or HIGH</confidence>
</answer>
```

**참고**  
기본 지침을 사용하지 않기로 결정할 경우 LLM이 제공하는 모든 출력이 최종 사용자에게 있는 그대로 반환됩니다.  
출력 지침에는 LLM이 응답 및 소스 특성을 제공하기 위해 passageIds를 반환할 수 있는 <text></text> 및 <passageId></passageId> 태그와 지침이 포함되어야 합니다.

**세션 속성을 통한 추가 컨텍스트 지원**

세션 속성를 통해 런타임 `AMAZON.QnAIntent` 시에 추가 컨텍스트를 전달할 수 있습니다`x-amz-lex:qna-additional-context`. 이렇게 하면 모델이 응답을 생성할 때 지식 스토어 결과와 함께 사용할 수 있는 보충 정보를 제공할 수 있습니다. 추가 컨텍스트는 `$additional_context$` 자리 표시자를 통해 프롬프트 템플릿에 삽입됩니다.

**예:**

```
{"sessionAttributes": {"x-amz-lex:qna-additional-context":"Our support hours are Monday through Friday, 8AM-8PM EST"}}
```

**세션 특성을 통한 Amazon Bedrock 지식 기반 메타데이터 필터링 지원**

세션 속성 `x-amz-lex:bkb-retrieval-filter`의 일부로 Amazon Bedrock 지식 기반 메타데이터 필터를 전달할 수 있습니다.

```
             {"sessionAttributes":{"x-amz-lex:bkb-retrieval-filter":"{\"equals\":{\"key\":\"insurancetype\",\"value\":\"farmers\"}}      
```

**참고**  
이 필터를 사용하려면 Amazon Bedrock 지식 기반을 QnAIntent의 데이터 스토어로 사용해야 합니다. 자세한 내용은 [https://docs.aws.amazon.com/bedrock/latest/userguide/kb-test-config.html#:~:text=Metadata%20and%20filtering](https://docs.aws.amazon.com/bedrock/latest/userguide/kb-test-config.html#:~:text=Metadata%20and%20filtering) 섹션을 참조하세요.

**추론 구성**

세션 특성을 사용하여 LLM에 직접적으로 호출할 때 사용할 추론 구성을 정의할 수 있습니다.
+ 온도: 정수 형식
+ topP
+ maxTokens

**예:**

```
         {"sessionAttributes":{"x-amz-lex:llm-text-inference-config":"{\"temperature\":0,\"topP\":1,\"maxTokens\":200}"}}      
```

**Bedrock 가드레일은 빌드 시간 및 세션 특성을 지원합니다.**
+ Buildtime에서 콘솔을 사용하여 GuardrailsIdentifier 및 GuardrailsVersion을 제공합니다. 추가 모델 구성 섹션에서 자세히 알아보세요.
+ 세션 특성을 사용하여 세션 특성인 `x-amz-lex:bedrock-guardrails-identifier` 및 `x-amz-lex:bedrock-guardrails-version`을 사용하여 가드레일 구성을 정의할 수도 있습니다.

Bedrock 가드레일 사용에 대한 자세한 내용은 [가드레일](https://docs.aws.amazon.com/bedrock/latest/userguide/guardrails.html)를 참조하세요.

# AMAZON.QnAIntent (multiple use support)
<a name="built-in-intent-qna-multi"></a>

로캘 내에 여러 AMAZON.QnAIntents를 포함할 수 있습니다. Amazon Lex V2는 봇 로캘 내에서 최대 5개의 AMAZON.QnAIntents를 지원합니다.

AMAZON.QnAIntent는 다음 사례 중 하나가 True인 경우 트리거될 수 있습니다.
+ 봇 로캘에 AMAZON.QnAIntent가 1개만 포함되어 있고 해당 의도에 샘플 발화가 포함되어 있지 않을 경우 발화가 봇에 있는 다른 의도로 분류되지 않을 때 활성화됩니다. 이 의도는 표현이 봇에 존재하는 다른 어떤 의도로도 분류되지 않을 때 활성화됩니다. 슬롯 값을 도출할 때 누락된 표현에 대해서는 이 의도가 활성화되지 않는다는 점에 유의하세요.
**참고**  
FM의 응답이 만족스럽지 않거나 FM에 대한 직접 호출이 실패하면 Amazon Lex V2는 `AMAZON.FallbackIntent`를 간접적으로 호출합니다.
+ AMAZON.QnAIntent에 샘플 발화가 포함될 경우 Amazon Lex V2가 사용자 입력에 따라 사용자가 해당 의도를 시작하려고 한다고 인식할 때만 활성화됩니다.
**참고**  
FM의 응답이 만족스럽지 않거나 FM에 대한 직접 호출이 실패하면 Amazon Lex V2는 이행 블록에 정의된 실패 다음 단계를 간접적으로 호출합니다.

**참고**  
`botLocale`에 1개 이상의 AMAZON.QnAIntent가 있을 경우 각 AMAZON.QnAIntent에는 샘플 발화가 1개 이상 있어야 합니다.

# AMAZON.QinConnectIntent
<a name="built-in-intent-qinconnect"></a>

**참고**  
Amazon Q In Connect를 사용하여 생성형 AI 기능을 사용하려면 다음 전제 조건을 완료해야 합니다.  
Amazon Connect 콘솔로 이동하여 인스턴스를 생성합니다. 아직 인스턴스가 없는 경우 [Amazon Connect 시작](https://docs.aws.amazon.com/connect/latest/adminguide/amazon-connect-get-started.html) 섹션을 참조하세요.
인스턴스에 대해 Amazon Q in Connect를 활성화하려면 [인스턴스에 대해 Amazon Q in Connect 활성화](https://docs.aws.amazon.com/connect/latest/adminguide/enable-q.html) 섹션을 참조하세요.

AMAZON.QinConnectIntent는 콜 센터 고객과 에이전트가 고객 문제를 빠르고 정확하게 해결할 수 있도록 실시간 권장 사항을 제공하는 Amazon Connect Wisdom의 LLM 강화 진화를 사용하여 고객 질문에 응답합니다. 이 의도는 표현이 봇에 존재하는 다른 어떤 의도로도 분류되지 않을 때 활성화됩니다. 슬롯 값을 도출할 때 누락된 표현에 대해서는 이 의도가 활성화되지 않는다는 점에 유의하세요. 인식되면 AMAZON.QinConnectIntent는 지정된 Q in Connect 도메인을 사용하여 구성된 Amazon Bedrock 지식 기반을 검색하고 고객 질문에 응답합니다.

**참고**  
동일한 봇 로캘에서 AMAZON.QinConnectIntent와 AMAZON.QnAIntent를 함께 사용할 수 없습니다.
미국 영어 이외의 다른 언어를 선택하는 경우 지정된 언어로 응답하도록 셀프 서비스 프롬프트(`SELF_SERVICE_PRE_PROCESSING` 및 `SELF_SERVICE_ANSWER_GENERATION`)를 사용자 지정해야 합니다. 프롬프트를 사용자 지정하는 방법에 대한 자세한 내용은 [Amazon Q in Connect 사용자 지정](https://docs.aws.amazon.com/connect/latest/adminguide/customize-q.html#ai-prompts-customize-q) 섹션을 참조하세요.

이 의도를 선택하는 경우에는 다음 필드를 구성한 다음 **의도 저장**을 선택하여 봇에 의도를 추가합니다.
+ Amazon Q In Connect 구성 - Amazon Q in Connect 어시스턴트의 Amazon 리소스 이름(ARN)을 제공합니다. 보조 ARN 패턴: `^arn:[a-z-]*?:wisdom:[a-z0-9-]*?:[0-9]{12}:[a-z-]*?/[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}(?:/[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}){0,2}$>`.

QinConnectIntent의 응답은 아래와 같이 요청 속성에 저장됩니다.
+ `x-amz-lex:q-in-connect-response` - 질문 또는 발화에 대한 QinConnectIntent의 응답입니다.

**QinConnectIntent에서 반환된 세션 속성**

QinConnect 의도와의 상호 작용은 세션 속성을 통한 대화에 대한 추가 데이터를 제공합니다.

1. `x-amz-lex:q-in-connect:session-arn` - 대화 중에 Amazon Q In Connect로 생성된 세션의 고유 식별자입니다.

1. `x-amz-lex:q-in-connect:conversation-status` - QinConnect 어시스턴트 또는 도메인과의 대화의 현재 상태입니다. 이 상태의 값은 다음 세 가지와 같습니다.
   + `CLOSED`
   + `READY`
   + `PROCESSING`

1. `x-amz-lex:q-in-connect:conversation-status-reason` - 위 속성으로 보고된 현재 상태의 이유를 제공합니다. 가능한 이유는 다음과 같습니다.
   + `SUCCESS` - 고객이 질문할 시간이 없고 질문에 성공적으로 답변했음을 나타냅니다.
   + `FAILED` - 고객의 질문에 답변하는 동안 오류가 발생했음을 나타냅니다. 대부분 고객의 질문을 이해하지 못했기 때문입니다.
   + `REJECTED` - 어시스턴트가 고객 질문에 답변하기를 거부하고 추가 정보를 얻기 위해 사람 또는 에이전트와 대화하는 등 봇 상호 작용 외부에서 질문을 처리하도록 권장하고 있음을 나타냅니다.

**참고**  
Amazon Connect 인스턴스에 의해 구동되는 고객 상호 작용 중에 QinConnectIntent가 있는 봇이 간접 호출되면 세션 ARN을 생성하여 Amazon Connect 인스턴스에서 전달해야 합니다. 세션을 생성하기 위해 Amazon Connect 흐름은 Amazon Q in Connect 단계로 구성할 수 있습니다.

**제한 사항 **
+ 동일한 봇 로캘에서 AMAZON.QnAIntent, AMAZON.BedrockAgentIntent 등 특정 발화가 없는 의도와 함께 AMAZON.QinConnectIntent를 함께 사용할 수 없습니다.
+ Amazon Connect 인스턴스에 의해 구동되는 고객 상호 작용 중에 QinConnectIntent가 있는 봇이 간접 호출되면 세션 ARN을 생성하여 Amazon Connect 인스턴스에서 전달해야 합니다. 세션을 생성하기 위해 Amazon Connect 흐름은 Amazon Q in Connect 단계로 구성할 수 있습니다.
+ 봇 로캘당 AMAZON.QinConnectIntent는 1개 이하일 수 있습니다.
+ AMAZON.QinConnectIntent와 함께 사용되는 Amazon Q in Connect 도메인은 Amazon Lex V2 봇과 동일한 AWS 리전에 있어야 합니다.

**권한**

Amazon Lex V2 봇에서 QinConnect 의도를 사용하고 봇이 서비스 연결 역할(SLR)을 사용하는 경우 Amazon Lex V2 서비스는 역할에 대한 적절한 정책을 업데이트하여 Q in Connect 어시스턴트와 통합할 수 있는 권한을 가집니다. 봇이 사용자 지정 IAM 역할을 사용하는 경우 사용자는 IAM 역할에 이러한 권한을 수동으로 추가해야 합니다.

QinConnect 의도가 추가되면 서비스 연결 역할이 다음 권한으로 업데이트됩니다. QinConnect 액세스에 대한 새 정책이 추가됩니다.

```
{
    "Version": "2012-10-17", 		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Sid": "QInConnectAssistantPolicy",
            "Action": [
                "wisdom:CreateSession",
                "wisdom:GetAssistant"
            ],
            "Resource": [
                "arn:aws:wisdom:*:accountId:assistant/assistantId",
                "arn:aws:wisdom:*:accountId:assistant/assistantId/*"
            ]
        },
        {
            "Effect": "Allow",
            "Sid": "QInConnectSessionsPolicy",
            "Action": [
                "wisdom:SendMessage",
                "wisdom:GetNextMessage"
            ],
            "Resource": [
                "arn:aws:wisdom:*:accountId:session/assistantId/*"
            ]
        },
        {
            "Sid": "QInConnectKmsCMKPolicy",
            "Effect": "Allow",
            "Action": [
                "kms:Decrypt",
                "kms:GenerateDataKey"
            ],
            "Resource": [
                "arn:aws:kms:region:accountId:key/keyId"
            ],
            "Condition": {
                "StringEquals": {
                    "aws:ResourceAccount": "accountId",
                    "kms:ViaService": "wisdom.region.amazonaws.com",
                    "kms:EncryptionContext:aws:wisdom:assistant:arn": ["arn:aws:wisdom:region:accountId:assistant/assistantId"]
                }
            }
        }
    ]
}
```

**참고**  
`QInConnectKmsCMKPolicy` 문은 Amazon Q in Connect 어시스턴트와 함께 고객 관리형 KMS 키를 사용하는 경우에만 필요합니다.

**신뢰 정책**

```
{
    "Effect": "Allow",
    "Sid": "LexV2InternalTrustPolicy",
    "Principal": {
        "Service": "lexv2.aws.internal"
    },
    "Action": "sts:AssumeRole",
    "Condition": {
        "StringEquals": {
            "aws:SourceAccount": "accountId"
        },
        "ArnLike": {
            "aws:SourceArn": "arn:aws:lex:*:accountId:bot-alias/botId/*"
        }
    }
}
```

# AMAZON.RepeatIntent
<a name="built-in-intent-repeat"></a>

사용자가 이전 메시지를 반복하게 할 수 있는 단어와 구문에 응답합니다. 애플리케이션은 Lambda 함수를 사용하여 이전 의도 정보를 세션 변수에 저장하거나 [GetSession](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_GetSession.html) 작업을 사용하여 이전 의도 정보를 가져와야 합니다.

공통 발화:
+ 반복
+ 다시 말해줘
+ 반복해줘

# AMAZON.ResumeIntent
<a name="built-in-intent-resume"></a>

사용자가 이전에 일시 중지된 의도를 재개할 수 있도록 단어와 구문에 응답합니다. Lambda 함수 또는 애플리케이션은 이전 의도를 재개하는 데 필요한 정보를 관리해야 합니다.

공통 표현:
+ 재개
+ 계속
+ 지속

# AMAZON.StartOverIntent
<a name="built-in-intent-start-over"></a>

사용자가 현재 의도 처리를 중단하고 처음부터 다시 시작할 수 있도록 하는 단어와 구문에 응답합니다. Lambda 함수 또는 `PutSession` 작업을 사용하여 첫 번째 슬롯 값을 다시 이끌어낼 수 있습니다.

공통 표현:
+ 다시 시작
+ 재시작
+ 다시 시작해

# AMAZON.StopIntent
<a name="built-in-intent-stop"></a>

사용자가 현재 의도 처리를 중단하고 봇과의 상호작용을 종료하기를 원한다는 것을 나타내는 단어와 문구에 응답합니다. Lambda 함수 또는 애플리케이션은 기존 속성 및 슬롯 유형 값을 모두 지운 다음 상호 작용을 종료해야 합니다.

공통 표현:
+ 멈춰
+ 꺼
+ 조용히 해

# 슬롯 유형 추가
<a name="add-slot-types"></a>

슬롯 유형은 사용자가 의도 변수에 제공할 수 있는 값을 정의합니다. 각 언어에 맞는 값이 되도록 각 언어의 슬롯 유형을 정의합니다. 예를 들어 페인트 색상을 나열하는 슬롯 유형에 영어로는 "red", 프랑스어로는 "rouge", 스페인어로는 "rojo"라는 값을 포함할 수 있습니다.

이 주제에서는 의도 슬롯에 값을 제공하는 사용자 지정 슬롯 유형을 생성하는 방법을 설명합니다. 내장 슬롯 유형을 표준값으로 사용할 수도 있습니다. 예를 들어 기본으로 제공되는 슬롯 유형은 `AMAZON.Country`를 사용하여 전 세계 국가 목록을 확인할 수 있습니다.

**슬롯 유형을 생성하려면**

1. AWS Management Console에 로그인하여 [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)에서 Amazon Lex 콘솔을 엽니다.

1. **봇 목록에서 언어를 추가하려는 봇을 선택하고 **대화 구조**를 선택한 다음 모든 언어**를 선택합니다.

1. 슬롯 유형을 추가할 언어를 선택한 다음 **슬롯 유형**을 선택합니다.

1. **슬롯 유형 추가**를 선택하고 슬롯 유형에 이름을 지정한 다음 **추가**를 선택합니다.

1. 슬롯 유형 편집기에서 슬롯 유형의 세부 정보를 추가합니다.
   + **슬롯 값 확인** - 슬롯 값을 확인하는 방법을 결정합니다. **값 확장**을 선택하면 Amazon Lex V2는 해당 값을 교육의 대표 값으로 사용합니다. **슬롯 값으로 제한**을 사용하는 경우 슬롯에 허용되는 값은 입력한 값으로 제한됩니다.
   + **슬롯 유형 값** – 슬롯에 대한 값입니다. **슬롯 값으로 제한**을 선택한 경우 값에 동의어를 추가할 수 있습니다. 예를 들어, “football” 값에 “soccer”라는 동의어를 추가할 수 있습니다. 사용자가 봇과의 대화에서 “soccer”를 입력하면 슬롯의 실제 값은 “football”입니다.
   + **슬롯 값을 사용자 지정 어휘로 사용** – 이 옵션을 활성화하면 음성 대화에서 슬롯 값과 동의어에 대한 인식을 개선하는 데 도움이 됩니다. 슬롯 값이 “예”, “아니오”, “하나”, “둘,” “셋” 등과 같이 일반적인 용어인 경우에는 이 옵션을 활성화하지 마십시오.

1. **저장 슬롯 유형**을 선택합니다.

Amazon Lex V2는 다음과 같은 슬롯 유형을 제공합니다.

**Topics**
+ [내장 슬롯 유형](built-in-slots.md)
+ [사용자 지정 슬롯 유형](custom-slot-types.md)
+ [문법 슬롯 유형](building-srgs.md)
+ [복합 슬롯 유형](composite-slots.md)

# 내장 슬롯 유형
<a name="built-in-slots"></a>

Amazon Lex는 슬롯의 데이터를 인식하고 처리하는 방법을 정의하는 내장 슬롯 유형을 지원합니다. 의도에 이러한 유형의 슬롯을 만들 수 있습니다. 따라서 날짜, 시간 및 위치와 같이 흔히 사용되는 슬롯 데이터의 열거 값을 만들 필요가 없습니다. 내장 슬롯 유형에는 버전이 없습니다.




| 슬롯 유형 | 간략한 설명 | 지원되는 로캘 | 
| --- | --- | --- | 
|  [AMAZON.AlphaNumeric](built-in-slot-alphanumeric.md)  | 문자와 숫자로 구성된 단어를 인식합니다. | 
|  [AMAZON.City](built-in-slot-city.md)  | 공항을 나타내는 단어를 인식합니다. | 모든 로캘 | 
|  [AMAZON.Confirmation](built-in-slot-confirmation.md)  | '예', '아니오', '아마도', '모릅니다'를 의미하는 단어를 인식하여 표준(예, 아니오, 아마도, 모름) 형식으로 변환합니다. | 모든 로캘 | 
|  [AMAZON.Country](built-in-slot-country.md)  | 공항을 나타내는 단어를 인식합니다. | 모든 로캘 | 
|  [AMAZON.Currency](built-in-slot-currency.md)  | 통화 값을 나타내는 단어를 표준 통화 약어 및 값으로 변환합니다. | 모든 로캘 | 
|  [AMAZON.Date](built-in-slot-date.md)  | 날짜를 나타내는 단어를 인식하여 표준 형식으로 변환합니다. | 모든 로캘 | 
|  [AMAZON.Duration](built-in-slot-duration.md)  | 지속 시간을 나타내는 단어를 인식하여 표준 형식으로 변환합니다. | 모든 로캘 | 
|  [AMAZON.EmailAddress](built-in-slot-email.md)  | 이메일 주소를 나타내는 단어를 표준 이메일 주소로 변환합니다. | 모든 로캘 | 
|  [AMAZON.FirstName](built-in-slot-first-name.md)  | 이름을 나타내는 단어를 인식합니다. | 모든 로캘 | 
|  [AMAZON.LastName](built-in-slot-last-name.md)  | 성을 나타내는 단어를 인식합니다. | 모든 로캘 | 
|  [AMAZON.Number](built-in-slot-number.md)  | 숫자 단어를 인식하여 숫자로 변환합니다. | 모든 로캘 | 
|  [AMAZON.Percentage](built-in-slot-percent.md)  | 백분율을 나타내는 단어를 숫자와 퍼센트 기호(%)로 변환합니다. | 모든 로캘 | 
|  [AMAZON.PhoneNumber](built-in-slot-phone.md)  | 전화번호를 나타내는 단어를 숫자 문자열로 변환합니다. | 모든 로캘 | 
|  [AMAZON.State](built-in-slot-state.md)  | 상태를 나타내는 단어를 인식합니다. | 모든 로캘 | 
|  [AMAZON.StreetName](built-in-slot-street-name.md)  | 거리 이름을 나타내는 단어를 인식합니다. | 모든 로캘 | 
|  [AMAZON.Time](built-in-slot-time.md)  | 시간을 나타내는 단어를 시간 형식으로 변환합니다. | 모든 로캘 | 
|  [AMAZON.UKPostalCode](built-in-slot-uk-postal-code.md)  | 영국 우편번호를 나타내는 단어를 인식하여 표준 양식으로 변환합니다. | 영어(영국)(en-GB)만 해당 | 
|  [AMAZON.FreeFormInput](built-in-slot-free-form.md)  | 임의의 단어나 문자로 구성된 문자열을 인식합니다. | 모든 로캘 | 

# AMAZON.AlphaNumeric
<a name="built-in-slot-alphanumeric"></a>

**APQ123**과 같은 문자와 숫자로 구성된 문자열을 인식합니다.

다음을 포함하는 문자열에 `AMAZON.AlphaNumeric` 슬롯 유형을 사용할 수 있습니다.
+ 알파벳 문자(예: **ABC**)
+ 숫자(예: **123**)
+ 영숫자 조합(예: **ABC123**)

`AMAZON.AlphaNumeric` 슬롯 유형은 철자 스타일을 사용한 입력을 지원합니다. 문자별 맞춤법 및 단어별 맞춤법 스타일을 사용하여 고객이 문자를 입력하는 데 도움을 줄 수 있습니다. 자세한 내용은 [대화하는 동안 맞춤법 스타일을 사용하여 슬롯 값 캡처](spelling-styles.md) 단원을 참조하세요.

`AMAZON.AlphaNumeric` 슬롯 유형에 정규식을 추가하여 슬롯에 입력된 값의 유효성을 검사할 수 있습니다. 예를 들어 정규식을 사용하여 다음 항목의 유효성을 검사할 수 있습니다.
+ 캐나다 우편번호
+ 운전 면허증 번호
+ 차량 식별 번호

표준 정규 표현식을 사용합니다. Amazon Lex V2는 정규 표현식에서 다음 문자를 지원합니다.
+ A\$1Z, a\$1z
+ 0\$19

Amazon Lex V2는 정규식에서 유니코드 문자도 지원합니다. 형식은 `\uUnicode`입니다. 유니코드 문자를 나타내려면 4자리 숫자를 사용합니다. 예를 들어 `[\u0041-\u005A]`는 [A\$1Z]와 같습니다.

다음 정규식 연산자는 지원되지 않습니다.
+ 무한 반복자: 상한이 없는 \$1, \$1 또는 \$1x,\$1
+ 와일드 카드(.)

정규식의 최대 길이는 300자입니다. 정규식을 사용하는 `AMAZON.AlphaNumeric` 슬롯 유형에 저장되는 문자열의 최대 길이는 30자입니다.

다음은 정규식의 몇 가지 예입니다.
+ **APQ123** 또는 **APQ1** 같은 영숫자 문자열: `[A-Z]{3}[0-9]{1,3}` 또는 보다 제약된 `[A-DP-T]{3} [1-5]{1,3}`
+ **CP123456789US**같은 USPS(US Postal Service) 국제 우선 취급 우편 형식: `CP[0-9]{9}US`
+ **123456789** 같은 은행 송금 번호: `[0-9]{9}`

슬롯 유형에 정규식을 설정하려면 콘솔 또는 [CreateSlotType](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateSlotType.html) 작업을 사용합니다. 슬롯 유형을 저장하면 정규식의 유효성이 검사됩니다. 정규식이 유효하지 않으면 Amazon Lex V2에서 오류 메시지가 반환됩니다.

슬롯 유형에 정규식을 사용하는 경우 Amazon Lex V2는 정규식과 대조하여 해당 유형의 슬롯에 대한 입력을 확인합니다. 입력이 정규식과 일치하면 해당 값이 슬롯에 허용되고, 입력이 정규식과 일치하지 않으면 Amazon Lex V2에서 다시 입력하라는 메시지가 표시됩니다.

# AMAZON.City
<a name="built-in-slot-city"></a>

지역 및 세계 도시 목록을 제공합니다. 슬롯 유형은 도시 이름의 일반적인 변형을 인식합니다. Amazon Lex V2는 변형을 공식 명칭으로 변환하지 않습니다.

예시:
+ 뉴욕
+ 레이캬비크
+ 도쿄
+ 베르사유

# AMAZON.Confirmation
<a name="built-in-slot-confirmation"></a>

이 슬롯 유형은 Amazon Lex V2의 '예', '아니오', '아마도', '모름' 문구와 단어에 해당하는 입력 구문을 인식하여 네 가지 값 중 하나로 변환합니다. 사용자의 확인 또는 승인을 캡처하는 데 사용할 수 있습니다. 최종 확인 값을 기반으로 조건을 만들어 여러 대화 경로를 설계할 수 있습니다.

예:

 \$1confirmation\$1 = "Yes"인 경우 의도 이행

 그러지 않으면 다른 슬롯 유도 

예시:
+ 예: Yeah, Yep, Ok, Sure, I have it, I can agree...
+ 아니요: Nope, Negative, Naw, Forget it, I'll decline, No way...
+ 아마도: It's possible, Perhaps, Sometimes, I might, That could be right...
+ 모릅니다: Dunno, Unknown, No idea, Not sure about it, Who knows...

2023년 8월 17일부터 “확인”이라는 기존 사용자 지정 슬롯 유형이 있는 경우 기본 제공 슬롯 확인과 충돌하지 않도록 이름을 변경해야 합니다. Lex 콘솔의 왼쪽 탐색 창에서 슬롯 유형(확인이라는 기존 사용자 지정 슬롯 유형의 경우)으로 이동하여 슬롯 유형 이름을 업데이트합니다. 새 슬롯 유형 이름은 기본 제공 확인 슬롯 유형의 전용 키워드인 “확인”이 아니어야 합니다.

# AMAZON.Country
<a name="built-in-slot-country"></a>

전 세계 국가의 이름입니다. 예시:
+ 호주
+ 독일
+ 일본
+ 미국
+ 우루과이

# AMAZON.Currency
<a name="built-in-slot-currency"></a>

통화를 나타내는 단어를 표준 ISO 4217 알파벳 통화 코드와 숫자로 변환합니다. Amazon Lex V2는 통화를 인식하되, 다른 통화로 환산하지 않습니다.

자세한 내용은 ISO(International Organization for Standardization) 웹사이트의 [Currency codes - ISO 4217](https://www.iso.org/iso-4217-currency-codes.html) 단원을 참조하세요.

표시 통화는 `{Unit} {Amount}`처럼 구성됩니다.
+ \$1Unit\$1은 특정 통화 단위(예: USD)를 나타냅니다.
+ \$1Amount\$1는 소수점 두 자리(예: 300.00)로 형식이 지정된 통화 값을 나타냅니다.

예제(아래의 모든 예제에서는 en-US 로캘 사용. 로캘마다 결과가 다를 수 있음):
+ “3USD”: USD 3.00
+ “USD300”: USD 300.00
+ “3 dimes” : USD 0.30
+ “\$11.56”: USD 1.56
+ “5c”: USD 0.05
+ “1 dollar”: USD 1.00
+ “five fifteen”: USD 515.00
+ “five dollars fifteen cents”: USD 5.15
+ “5 usd and 1/2”: USD 5.50

# AMAZON.Date
<a name="built-in-slot-date"></a>

날짜를 나타내는 단어를 날짜 형식으로 변환합니다.

날짜는 의도에 ISO-8601 날짜 형식으로 제공됩니다. 의도가 슬롯에서 수신되는 날짜는 사용자가 말한 특정 문구에 따라 달라질 수 있습니다.
+ "오늘", "지금" 또는 "11월 25일"과 같이 특정 날짜에 매핑되는 표현은 전체 날짜로 변환됩니다: `2020-11-25`. 기본값은 *현재 날짜 또는 그 이후*의 날짜입니다.
+ "다음 주"와 같이 미래 주에 매핑되는 표현은 현재 주의 마지막 날 날짜로 변환됩니다. ISO-8601 형식에서는 한 주가 월요일에 시작하여 일요일에 끝납니다. 예를 들어 오늘이 2020-11-25인 경우 "다음 주"는 `2020-11-29`로 변환됩니다. 현재 또는 이전 주에 매핑되는 날짜는 주의 첫 번째 날로 변환됩니다. 예를 들어 오늘이 2020-11-25인 경우 "지난 주"는 `2020-11-16`로 변환됩니다.
+ "다음 달"과 같이 특정 날짜가 아닌 미래 달에 매핑되는 표현은 해당 월의 마지막 날로 변환됩니다. 예를 들어 오늘이 2020-11-25인 경우 "다음 달"은 `2020-12-31`로 변환됩니다. 현재 또는 이전 달에 매핑되는 날짜의 경우 해당 달의 첫 번째 날로 변환됩니다. 예를 들어 오늘이 2020-11-25인 경우 "이번 달"은 `2020-11-01`에 매핑됩니다.
+ 미래 연도에 매핑되지만 특정 월이나 요일은 아닌 표현(예: "다음 연도")는 다음 해의 마지막 날로 변환됩니다. 예를 들어 오늘이 2020-11-25인 경우 "다음 연도"는 `2021-12-31`로 변환됩니다. 현재 또는 이전 연도에 매핑되는 날짜의 경우 해당 연도의 첫 번째 날로 변환됩니다. 예를 들어 오늘이 2020-11-25인 경우 "지난 연도"는 `2019-01-01`로 변환됩니다.

# AMAZON.Duration
<a name="built-in-slot-duration"></a>

지속 시간을 나타내는 단어를 지속 시간으로 변환합니다.

지속 시간은 [ISO-8601 지속 시간 형식](https://en.wikipedia.org/wiki/ISO_8601#Durations), `PnYnMnWnDTnHnMnS`를 기반으로 하는 형식으로 확인됩니다. `P`은 해당 사항이 기간이며, `n`가 숫자 값이고, `n` 뒤에 오는 대문자가 특정 날짜 또는 시간 요소임을 나타냅니다. 예를 들어, `P3D`은 3일을 의미합니다. `T`는 나머지 값이 날짜 요소가 아닌 시간 요소를 나타낸다는 것을 나타내는 데 사용됩니다.

예시:
+ "10분": `PT10M`
+ "다섯 시간": `PT5H`
+ "3일": `P3D`
+ "45초": `PT45S`
+ "8주": `P8W`
+ "7년": `P7Y`
+ "5시간 10분": `PT5H10M`
+ "2년 3시간 10분": `P2YT3H10M`

# AMAZON.EmailAddress
<a name="built-in-slot-email"></a>

username@domain으로 제공된 이메일 주소를 나타내는 단어를 인식합니다. 주소에는 사용자 이름 부분에 밑줄(\$1), 하이픈(-), 마침표(.) 및 더하기 기호(\$1)와 같은 특수 문자를 포함할 수 있습니다.

`AMAZON.EmailAddress` 슬롯 유형은 철자 스타일을 사용한 입력을 지원합니다. 문자별 맞춤법 및 단어별 맞춤법 스타일을 사용하여 고객이 이메일 주소를 입력하는 데 도움을 줄 수 있습니다. 자세한 내용은 [대화하는 동안 맞춤법 스타일을 사용하여 슬롯 값 캡처](spelling-styles.md) 단원을 참조하세요.

# AMAZON.FirstName
<a name="built-in-slot-first-name"></a>

일반적으로 사용되는 이름입니다. 이 슬롯 유형은 공식 이름, 비공식 별명 및 하나 이상의 단어로 구성된 이름을 인식합니다. 의도에 전송된 이름은 사용자가 보낸 값입니다. Amazon Lex V2는 별명을 정식 이름으로 변환하지 않습니다.

비슷하지만 철자가 다른 이름의 경우 Amazon Lex V2는 의도에 단일 공통 양식을 전송합니다.

`AMAZON.FirstName` 슬롯 유형은 철자 스타일을 사용한 입력을 지원합니다. 문자별 맞춤법 및 단어별 맞춤법 스타일을 사용하여 고객이 이름을 입력하는 데 도움을 줄 수 있습니다. 자세한 내용은 [대화하는 동안 맞춤법 스타일을 사용하여 슬롯 값 캡처](spelling-styles.md) 단원을 참조하세요.

예시:
+ 에밀리
+ 존
+ Sophie
+ Anil Kumar

또한 AMAZON.FirstName은 원래 값을 기반으로 밀접하게 관련된 이름의 목록을 반환합니다. 확인된 값 목록을 사용하여 오타를 복구하거나, 사용자에게 이름을 확인하거나, 사용자 디렉터리에서 유효한 이름을 찾기 위해 데이터베이스를 검색할 수 있습니다.

예를 들어, “John”을 입력하면 “John J” 및 “John-Paul”과 같은 관련 이름이 추가로 반환될 수 있습니다.

다음은 `AMAZON.FirstName` 내장 슬롯 유형에 대한 응답 형식을 보여줍니다.

```
"value": {
    "originalValue": "John",
    "interpretedValue": "John",
    "resolvedValues": [
        "John",
        "John J.",
        "John-Paul"
    ]
}
```

# AMAZON.LastName
<a name="built-in-slot-last-name"></a>

일반적으로 사용되는 성입니다. 철자가 다르지만 비슷하게 들리는 이름의 경우 Amazon Lex V2는 의도에 단일 공통 양식을 전송합니다.

`AMAZON.LastName` 슬롯 유형은 철자 스타일을 사용한 입력을 지원합니다. 문자별 맞춤법 및 단어별 맞춤법 스타일을 사용하여 고객이 이름을 입력하는 데 도움을 줄 수 있습니다. 자세한 내용은 [대화하는 동안 맞춤법 스타일을 사용하여 슬롯 값 캡처](spelling-styles.md) 단원을 참조하세요.

예시:
+ 브로스키
+ 대셔
+ 에버스
+ 파레스
+ Welt

또한 AMAZON.LastName은 원래 값을 기반으로 밀접하게 관련된 이름의 목록을 반환합니다. 확인된 값 목록을 사용하여 오타를 복구하거나, 사용자에게 이름을 확인하거나, 사용자 디렉터리에서 유효한 이름을 찾기 위해 데이터베이스를 검색할 수 있습니다.

예를 들어, “Smith”를 입력하면 “Smyth” 및 “Smithe”와 같은 관련 이름이 추가로 반환될 수 있습니다.

다음은 `AMAZON.LastName` 내장 슬롯 유형에 대한 응답 형식을 보여줍니다.

```
"value": {
    "originalValue": "Smith",
    "interpretedValue": "Smith",
    "resolvedValues": [
        "Smith",
        "Smyth",
        "Smithe"
    ]
}
```

# AMAZON.Number
<a name="built-in-slot-number"></a>

숫자를 표현하는 단어나 숫자를 십진수를 포함한 숫자로 변환합니다. 다음 표에는 `AMAZON.Number` 슬롯 유형이 숫자 단어를 캡처하는 방식이 나와 있습니다.


| 입력 | 응답 | 
| --- | --- | 
| 백이십삽점사오 | 123.45 | 
| 백이십삼점사오 | 123.45 | 
| 영점사이 | 0.42 | 
| 영점사이 | 0.42 | 
| 232.998 | 232.998 | 
| 50 | 50 | 
| -15 | -15 | 
| 마이너스 15 | -15 | 
| 15점 245 빼기 | -15.245 | 

# AMAZON.Percentage
<a name="built-in-slot-percent"></a>

백분율을 나타내는 단어와 기호를 숫자와 퍼센트 기호(%)로 변환합니다.

사용자가 퍼센트 기호 또는 "퍼센트"라는 단어 없이 숫자를 입력하면 슬롯 값은 숫자로 설정됩니다. 다음 표에는 `AMAZON.Percentage` 슬롯 유형이 백분율을 캡처하는 방식이 나와 있습니다.


| 입력 | 응답 | 
| --- | --- | 
| 50 퍼센트 | 50% | 
| 0.4 퍼센트 | 0.4% | 
| 23.5% | 23.5% | 
| 이십오 퍼센트 | 25% | 

# AMAZON.PhoneNumber
<a name="built-in-slot-phone"></a>

전화번호를 나타내는 숫자 또는 단어를 다음과 같이 구두점이 없는 문자열 형식으로 변환합니다.


| 유형 | 설명 | 입력 | 결과 | 
| --- | --- | --- | --- | 
| 앞에 더하기(\$1) 기호가 표시된 국제 전화번호 | 앞에 더하기 기호가 표시된 11자리 숫자 |  \$161 7 4445 1061 \$11 (509) 555-1212  |   `+61744431061`   `+15095551212`   | 
| 앞에 더하기(\$1) 기호가 표시되지 않은 국제 전화번호 | 앞에 더하기 기호가 표시되지 않은 11자리 숫자 |  1 (509) 555-1212 61 7 4445 1061  |   `15095551212`   `61744451061`   | 
| 국내 전화번호 | 국가 번호가 표시되지 않은 10자리 숫자 |  (03) 5115 4444 (509) 555-1212  |   `0351154444`   `5095551212`   | 
| 시내 전화번호 | 국가 번호 또는 지역 번호가 표시되지 않은 전화번호 | 555-1212 |  5551212  | 

# AMAZON.State
<a name="built-in-slot-state"></a>

국가 내 지리적 및 정치적 지역의 이름.

예시:
+ 바이에른
+ 후쿠시마 현
+ 퍼시픽 노스웨스트
+ 퀸즐랜드
+ 웨일스

# AMAZON.StreetName
<a name="built-in-slot-street-name"></a>

일반적인 도로명 주소 내의 거리 이름. 여기에는 집 번호가 아닌 도로명만 포함됩니다.

예시:
+ 캔버라 애비뉴
+ 프론트 스트리트
+ 마켓 로드

# AMAZON.Time
<a name="built-in-slot-time"></a>

시간을 나타내는 단어를 시간 값으로 변환합니다. `AMAZON.Time`은 정확한 시간, 모호한 값 및 시간 범위를 확인할 수 있습니다. 슬롯 값은 다음 시간 범위로 해석될 수 있습니다.
+ 오전
+ 오후
+ MO(아침)
+ AF(오후)
+ EV(저녁)
+ NI(야간)

사용자가 모호한 시간을 입력하면 Amazon Lex V2는 Lambda 이벤트의 `slots` 속성을 사용하여 모호한 시간에 대한 확인을 Lambda 함수 로 전달합니다. 예를 들어 봇이 사용자에게 배송 시간을 입력하라는 메시지를 표시하면 사용자는 "10시 정각"이라고 응답할 수 있습니다. 사용자가 응답한 시간은 모호합니다. 이 시간은 10 AM 또는 10 PM을 의미할 수 있습니다. 이 경우 `interpretedValue` 필드의 값은 `null`이고 `resolvedValues` 필드에는 이 시간에 대해 가능한 두 가지 확인이 포함되어 있습니다. 는 함수에 다음과 같이 입력합니다. Amazon Lex V2는 다음 이벤트를 사용하여 Lambda 함수를 호출합니다.

```
"slots": {
    "deliveryTime": {
    "value": {
        "originalValue": "10 o'clock",
        "interpretedValue": null,
        "resolvedValues": [
            "10:00", "22:00"
        ]
    }
}
```

사용자가 모호한 시간으로 응답하면 Amazon Lex V2는 해당 시간을 Lambda 이벤트의 `slots` 속성 `interpretedValue` 필드에 있는 Lambda 함수에 시간을 전송합니다. 예를 들어 사용자가 배송 시간을 묻는 메시지에 "오전 10시"이라고 응답하면 Amazon Lex V2는 Lambda 함수에 다음과 같이 입력합니다.

```
"slots": {
    "deliveryTime": {
        "value": {
        "originalValue": "10 AM",
        "interpretedValue": 10:00,
        "resolvedValues": [
            "10:00"
        ]
    }
}
```

사용자가 배송 시간을 묻는 메시지에 "오전 중"이라고 응답하면 Amazon Lex V2는 Lambda 함수에 다음을 입력합니다.

```
"slots": {
    "deliveryTime": {
    "value": {
        "originalValue": "morning",
        "interpretedValue": "MO",
        "resolvedValues": [
            "MO"
        ]
    }
}
```

Amazon Lex V2에서 Lambda 함수로 보낸 데이터에 대한 자세한 내용은 [AWS LambdaLex V2의 입력 이벤트 형식](lambda-input-format.md) 섹션을 참조하세요.

# AMAZON.UKPostalCode
<a name="built-in-slot-uk-postal-code"></a>

영국 우편번호를 나타내는 단어를 영국 우편 번호의 표준 형식으로 변환합니다. `AMAZON.UKPostalCode` 슬롯 유형은 우편번호의 유효성을 검사하고 표준화된 형식 집합으로 해석하지만 우편번호가 유효한지 확인하지는 않습니다. 애플리케이션에서 우편번호를 검증해야 합니다.

이 `AMAZON.UKPostalCode` 슬롯 유형은 영어(영국)(en-GB) 로캘에서만 사용할 수 있습니다.

`AMAZON.UKPostalCode` 슬롯 유형은 철자 스타일을 사용한 입력을 지원합니다. 문자별 맞춤법 및 단어별 맞춤법 스타일을 사용하여 고객이 문자를 입력하는 데 도움을 줄 수 있습니다. 자세한 내용은 [대화하는 동안 맞춤법 스타일을 사용하여 슬롯 값 캡처](spelling-styles.md) 단원을 참조하세요.

슬롯 유형은 아래와 같이 영국에서 사용되는 모든 유효한 우편번호 형식을 인식합니다. 유효한 형식은 다음과 같습니다(“A”는 문자, “9”는 숫자).
+ AA9A 9AA
+ A9A 9AA
+ A9 9AA
+ A99 9AA
+ AA9 9AA
+ AA99 9AA

텍스트 입력의 경우 사용자는 대문자와 소문자를 혼합하여 입력할 수 있습니다. 사용자는 우편번호의 공백을 사용하거나 생략할 수 있습니다. 확인된 값에는 항상 우편번호를 넣을 적절한 위치의 공백이 포함됩니다.

음성 입력의 경우 사용자는 개별 문자를 말하거나 “double A” 또는 “double 9"와 같은 이중 문자 발음을 사용할 수 있습니다. 또한 “99”의 경우 “아흔아홉”과 같이 두 자리 발음을 사용할 수도 있습니다.

**참고**  
일부 영국 우편번호는 인식되지 않을 수 있습니다. 위에 나열된 형식만 지원됩니다.

# AMAZON.FreeFormInput
<a name="built-in-slot-free-form"></a>

`AMAZON.FreeFormInput`을 사용하여 최종 사용자의 자유 형식 입력을 캡처할 수 있습니다. 단어나 문자로 구성된 문자열을 인식합니다. 확인된 값은 전체 입력 발화입니다.

예시

봇: 통화 경험에 대한 피드백을 제공해 주세요.

사용자: 모든 질문에 대한 답변을 얻었고 거래를 완료할 수 있었습니다.

참고:
+ `AMAZON.FreeFormInput`을 사용하여 최종 사용자의 자유 형식 입력을 있는 그대로 캡처할 수 있습니다.
+ `AMAZON.FreeFormInput`은 의도 샘플 발화에 사용할 수 없습니다.
+ `AMAZON.FreeFormInput`은 슬롯 샘플 발화를 포함할 수 없습니다.
+ `AMAZON.FreeFormInput`은 요청된 경우에만 인식됩니다.
+ `AMAZON.FreeFormInput`은 대기 및 계속을 지원하지 않습니다.
+ `AMAZON.FreeFormInput`은 현재 Amazon Connect 채팅 채널에서 지원되지 않습니다.
+ `AMAZON.FreeFormInput` 슬롯이 유도될 경우 `FallbackIntent`는 트리거되지 않습니다.
+ `AMAZON.FreeFormInput` 슬롯이 유도될 경우 의도 전환은 발생하지 않습니다.

# 사용자 지정 슬롯 유형
<a name="custom-slot-types"></a>

각 의도에 대해 사용자의 요청을 이행하기 위해 의도에 필요한 정보를 나타내는 파라미터를 지정할 수 있습니다. 이러한 파라미터 또는 슬롯에는 일종의 유형이 있습니다. *슬롯 유형*은 Amazon Lex V2가 슬롯에 대한 값을 인식하기 위해 기계 학습 모델을 학습하는 데 사용하는 값 목록입니다. 예를 들어 'comedy', 'adventure', 'documentary' 등과 같은 값을 사용하여 `Genres`라는 슬롯 유형을 정의할 수 있습니다. 슬롯 유형 값에 대한 동의어를 정의할 수 있습니다. 예를 들어 "코미디" 값에 대한 동의어로 "재밌는" 및 "유머러스한"를 정의할 수 있습니다.

![\[사용자 지정 슬롯 유형을 생성합니다.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/slots/custom-slot-type.png)


값을 확장하도록 슬롯 유형을 구성할 수 있습니다. 슬롯 값은 학습 데이터로 사용되며, 모델은 슬롯 값 및 해당 값의 동의어와 유사한 경우 사용자가 제공한 값으로 슬롯을 해결합니다. 이는 기본 설정 동작입니다. Amazon Lex V2는 슬롯에 가능한 확인 목록을 유지 관리합니다. 목록의 각 항목은 Amazon Lex V2가 슬롯의 추가 가능함으로 인식한 *확인 값*을 제공합니다. 확인된 값은 슬롯 값을 일치시키기 위한 최적의 방편입니다. 확인 목록에는 최대 다섯 개의 값이 포함됩니다.

또는 슬롯 값에 대한 확인을 제한하도록 슬롯 유형을 구성할 수 있습니다. 이 경우 모델은 사용자가 입력한 슬롯 값이 해당 슬롯 값과 같거나 동의어인 경우에만 기존 슬롯 값으로 해석합니다. 예를 들어 사용자가 "재밌는"를 입력하면 슬롯 값 "코미디"로 확인됩니다.

사용자가 입력한 값이 슬롯 유형 값의 동의어인 경우 모델은 해당 슬롯 유형 값을 `resolvedValues` 목록의 첫 번째 항목으로 반환합니다. 예를 들어, 사용자가 “funny”을 입력하면 모델은 `originalValue` 필드에 “funny” 값을 입력하고 resolvedValues 필드의 첫 번째 항목을 “comedy”로 채웁니다. [CreateSlotType](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateSlotType.html) 작업을 사용하여 슬롯 유형을 생성 또는 업데이트할 때 슬롯 값이 확인 목록의 첫 번째 값으로 채워지도록 `valueSelectionStrategy`를 구성할 수 있습니다.

 사용자 지정 슬롯 유형은 맞춤법 스타일을 사용하여 입력을 지원합니다. 문자별 맞춤법 및 단어별 맞춤법 스타일을 사용하여 고객이 문자를 입력하는 데 도움을 줄 수 있습니다. 자세한 내용은 [대화하는 동안 맞춤법 스타일을 사용하여 슬롯 값 캡처](spelling-styles.md) 단원을 참조하세요.

 Lambda 함수를 사용하는 경우 이 함수의 입력 이벤트에는 `resolvedValues`라는 확인 목록이 포함되어 있습니다. 다음 예는 Lambda 함수에 대한 입력의 슬롯 섹션을 보여줍니다.

```
   "slots": {
      "MovieGenre": {
         "value": {
            "originalValue": "funny",
            "interpretedValue": "comedy",
            "resolvedValues": [
               "comedy"
            ]
         }
      }
   }
```

각 슬롯 유형에 대해 값과 동의어는 최대 10,000개까지 정의할 수 있습니다. 각 봇은 슬롯 유형 값 및 동의어를 합해 최대 50,000개까지 포함할 수 있습니다. 예를 들면, 각각 5,000개 값과 5,000개 동의어를 가진 5개의 슬롯 유형을 가지거나 아니면 각각 2,500개 값과 2,500개 동의어를 가진 10개의 슬롯 유형을 가질 수 있습니다.

사용자 지정 슬롯 유형의 이름은 내장 슬롯 유형과 같아서는 안 됩니다. 예를 들어 날짜, 번호 또는 확인이라는 예약된 키워드를 사용하여 사용자 지정 슬롯 유형의 이름을 지정해서는 안 됩니다. 이러한 키워드는 내장 슬롯 유형에만 사용됩니다. 내장 슬롯 유형 목록은 [내장 슬롯 유형](built-in-slots.md) 단원을 참조하세요.

# 문법 슬롯 유형
<a name="building-srgs"></a>

문법 슬롯 유형을 사용하면 SRGS 사양에 따라 XML 형식으로 자신만의 문법을 작성하여 대화에서 정보를 수집할 수 있습니다. Amazon Lex V2는 문법에 지정된 규칙과 일치하는 발화를 인식합니다. 문법 파일 내의 ECMAScript 태그를 사용하여 의미론적 해석 규칙을 제공할 수도 있습니다. 그러면 Amazon Lex는 매칭이 발생할 경우 태그에 설정된 속성을 확인된 값으로 반환합니다.

영어(호주), 영어(영국) 및 영어(미국) 로캘에서만 문법 슬롯 유형을 생성할 수 있습니다.

문법 슬롯 유형에는 두 부분이 있습니다. 첫 번째는 SRGS 사양 형식을 사용하여 작성된 문법 자체입니다. 문법은 사용자의 발화를 해석합니다. 발화가 문법에 의해 받아들여지면 매칭되고 그러지 않으면 거부됩니다. 매칭되는 발화가 있는 경우 대화 기록에 전달됩니다.

두 번째는 문법 슬롯 타입의 일부로, 입력을 슬롯 타입이 반환하는 해석된 값으로 변환하는 ECMAScript로 작성된 선택적 스크립트입니다. 예를 들어 대화 기록을 사용하여 음성 숫자를 숫자로 변환할 수 있습니다. ECMAScript 문은 <tag> 요소로 묶여 있습니다.

다음 예시는 Amazon Lex V2에서 허용하는 유효한 문법을 보여주는 SRGS 사양에 따른 XML 형식입니다. 카드 번호를 허용하는 문법 슬롯 유형을 정의하고 일반 계정용인지 프리미엄 계정용인지 결정합니다. 허용되는 구문에 대한 자세한 내용은 [문법 정의](grammar-srgs-spec.md) 및 [스크립트 형식](grammar-ecmascript-spec.md) 주제를 참조하세요.

```
<grammar version="1.0" xmlns="http://www.w3.org/2001/06/grammar"
         xml:lang="en-US" tag-format="semantics/1.0" root="card_number">

   <rule id="card_number" scope="public">
        <item repeat="0-1">
            card number
        </item>
        <item>
            seven
            <tag>out.value = "7";</tag>
         </item>
         <item>
            <one-of>
               <item>
                  two four one
                  <tag> out.value = out.value + "241"; out.card_type = "premium"; </tag>
               </item>
               <item>
                  zero zero one
                  <tag> out.value = out.value + "001"; out.card_type = "regular";</tag>
               </item>
            </one-of>
         </item>
   </rule>
</grammar>
```

위 문법에서는 7241 또는 7001의 두 가지 유형의 카드 번호만 사용할 수 있습니다. 두 번호 모두 선택적으로 앞에 “카드 번호”를 붙일 수 있습니다. 또한 의미론적 해석에 사용할 수 있는 ECMAScript 태그도 포함되어 있습니다. 의미론적 해석을 사용할 경우 “카드 번호 7 2 4 1”이라는 문구는 다음과 같은 객체를 반환합니다.

```
{
    "value": "7241",
    "card_type": "premium"
}
```

이 객체는 [RecognizeText](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeText.html), [RecognizeUtterance](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeUtterance.html) 및 [StartConversation](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_StartConversation.html) 작업에서 반환되는 `resolvedValues` 객체에서 JSON 직렬화 문자열로 반환됩니다.

## 문법 슬롯 유형 추가
<a name="adding-grammar-slot-type"></a>

**문법 슬롯 유형을 추가하려면**

1. 슬롯 유형의 XML 정의를 S3 버킷에 업로드합니다. 버킷 이름과 파일 경로를 메모해 두세요.
**참고**  
최대 파일 크기는 100KB입니다.

1. AWS Management Console에 로그인하여 [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)에서 Amazon Lex 콘솔을 엽니다.

1. 왼쪽 메뉴에서 **봇**을 선택한 다음 문법 슬롯 유형을 추가할 봇을 선택합니다.

1. **언어 보기**를 선택한 다음 문법 슬롯 유형을 추가할 언어를 선택합니다.

1. **슬롯 유형 보기**를 선택합니다.

1. **슬롯 유형 추가**를 선택한 다음 **문법 슬롯 유형 추가**를 선택합니다.

1. 슬롯 유형에 이름을 지정한 다음 **추가**를 선택합니다.

1. 정의 파일이 포함된 S3 버킷을 선택하고 파일의 경로를 입력합니다. **저장 슬롯 유형**을 선택합니다.

# 문법 정의
<a name="grammar-srgs-spec"></a>

이 주제에서는 Amazon Lex V2가 지원하는 SRGS 사양의 일부를 보여줍니다. 모든 규칙은 SRGS 사양에 정의되어 있습니다. 자세한 내용은 [음성 인식 문법 사양 버전 1.0](https://www.w3.org/TR/speech-grammar/) W3C 권장 사항을 참조하세요.

**Topics**
+ [헤더 선언](srgs-header.md)
+ [지원되는 XML 요소](srgs-supported-xml.md)
+ [토큰](srgs-tokens.md)
+ [규칙 참조](srgs-rule-reference.md)
+ [시퀀스 및 캡슐화](srgs-sequence.md)
+ [반복](srgs-repeats.md)
+ [언어](srgs-language.md)
+ [Tags](srgs-tags.md)
+ [가중치](grammar-weights.md)

이 문서에는 W3C 음성 인식 문법 사양 버전 1.0([https://www.w3.org/TR/speech-grammar/](https://www.w3.org/TR/speech-grammar/) 참조) 에서 복사 및 파생된 자료가 포함되어 있습니다. 인용 정보는 다음과 같습니다.

[Copyright](http://www.w3.org/Consortium/Legal/ipr-notice#Copyright) © 2004 [W3C®](http://www.w3.org/) ([MIT](http://www.csail.mit.edu/), [ERCIM](http://www.ercim.org/), [Keio](http://www.keio.ac.jp/), All Rights Reserved. W3C [책임](http://www.w3.org/Consortium/Legal/ipr-notice#Legal_Disclaimer), [상표권](http://www.w3.org/Consortium/Legal/ipr-notice#W3C_Trademarks), [문서 사용](http://www.w3.org/Consortium/Legal/copyright-documents) 및 [소프트웨어 라이선스](http://www.w3.org/Consortium/Legal/copyright-software) 규칙이 적용됩니다.

[W3C 권장 사항](https://www.w3.org/2004/02/Process-20040205/tr.html#RecsW3C)인 SRGS 사양 문서는 다음 라이선스에 따라 W3C에서 제공됩니다.

## 라이선스 텍스트
<a name="license-text"></a>

라이선스

이 문서 또는 본 설명서가 링크된 W3C 문서를 사용 및/또는 복사함으로써 귀하(사용권자)는 다음 이용 약관을 읽고 이해했으며 준수하는 것에 동의하게 됩니다.

사용하는 문서의 모든 사본 또는 그 일부에 다음 사항을 포함하는 경우, 본 문서의 내용 또는 본 설명서가 링크된 W3C 문서를 어떤 목적으로든 수수료 또는 로열티 없이 모든 매체에서 복사 및 배포할 수 있는 권한이 부여됩니다.
+ 원본 W3C 문서에 대한 링크 또는 URL.
+ 원저자의 기존 저작권 고지 또는 존재하지 않는 경우, "Copyright © [\$1date-of-document] [World Wide Web Consortium](http://www.w3.org/), ([MIT](http://www.csail.mit.edu/), [ERCIM](http://www.ercim.org/), [Keio](http://www.keio.ac.jp/), [Beihang](http://ev.buaa.edu.cn/)). [http://www.w3.org/Consortium/Legal/2015/doc-license](http://www.w3.org/Consortium/Legal/2015/doc-license)" 형식의 고지(가급적 하이퍼텍스트를 사용하되 텍스트 표현은 허용됨)
+ *존재하는 경우*, W3C 문서의 상태.

공간에 여유가 있을 경우, 본 **고지**의 전문을 포함해야 합니다. 당사는 이 문서의 내용 또는 그 일부의 구현에 따라 사용자가 만드는 모든 소프트웨어, 문서 또는 기타 항목이나 제품에 저작권 표시를 제공하도록 요청합니다.

다음과 같은 경우를 제외하고 이 라이선스에 따라 W3C 문서를 수정하거나 파생 문서를 만들 수 있는 권리는 부여되지 않습니다. 이 문서에 명시된 기술 사양의 구현을 용이하게 하기 위해 누구든지 소프트웨어, 소프트웨어와 함께 제공되는 지원 자료 및 소프트웨어 설명서에 이 문서의 파생 저작물 및 일부를 준비하고 배포할 수 있습니다. 단, 그러한 모든 저작물에 아래 고지가 포함되어 있어야 합니다. 그러나 기술 사양으로 사용하기 위한 이 문서의 파생 저작물의 출판은 명시적으로 금지됩니다.

또한 웹 IDL로 명확하게 표시된 섹션의 웹 IDL과 W3C 정의 마크업(HTML, CSS 등) 및 코드 예제로 명확하게 표시된 컴퓨터 프로그래밍 언어 코드인 '코드 구성 요소'는 [W3C 소프트웨어 라이선스](http://www.w3.org/Consortium/Legal/copyright-software)에 따라 사용이 허가됩니다.

고지는 다음과 같습니다.

"Copyright © 2015 W3C® (MIT, ERCIM, Keio, Beihang). 이 소프트웨어 또는 문서에는 [W3C 문서의 제목 및 URI]에서 복사하거나 파생된 자료가 포함되어 있습니다.”

면책 조항

본 문서는 “있는 그대로” 제공되며, 저작권 소유자는 상품성, 특정 목적에의 적합성, 비침해성 또는 소유권에 대한 보증을 포함하되 이에 국한되지 않고, 문서의 내용이 특정 목적에 적합하며 그러한 내용의 구현이 제3자의 특허, 저작권, 상표 또는 기타 권리를 침해하지 않는다는 명시적 또는 묵시적 진술이나 보증을 하지 않습니다.

저작권 소유자는 문서 사용 또는 문서 내용의 실행 또는 구현으로 인해 발생하는 직접적, 간접적, 특별 또는 결과적 손해에 대해 책임을 지지 않습니다.

저작권 소유자의 이름과 상표는 명시적인 사전 서면 허가 없이는 이 문서 또는 그 내용과 관련된 광고 또는 홍보에 사용할 수 없습니다. 이 문서의 저작권에 대한 소유권은 항상 저작권 소유자에게 있습니다.

# 헤더 선언
<a name="srgs-header"></a>

다음 표에는 문법 슬롯 유형이 지원하는 헤더 선언이 나와 있습니다. 자세한 내용은 *음성 인식 문법 사양 버전 1* W3C 권장 사항의 [문법 헤더 선언](https://www.w3.org/TR/speech-grammar/#S4.1)을 참조하세요.


| 선언 | 사양 요구 사항 | XML 양식 | Amazon Lex 지원 | 사양 | 
| --- | --- | --- | --- | --- | 
| 문법 버전 | 필수 | [4.3](https://www.w3.org/TR/speech-grammar/#S4.3): grammar 요소의 version 속성 | 필수 | SRGS | 
| XML 네임스페이스 | 필수(XML만 해당) | [4.3](https://www.w3.org/TR/speech-grammar/#S4.3): grammar 요소의 xmlns 속성 | 필수 | SRGS | 
| 문서 유형 | 필수(XML만 해당) | [4.3](https://www.w3.org/TR/speech-grammar/#S4.3): XML 문서 유형 | 권장 | SRGS | 
| 문자 인코딩 | 권장 | [4.4](https://www.w3.org/TR/speech-grammar/#S4.4): XML 선언의 encoding 속성 | 권장 | SRGS | 
| 언어 | 음성 모드에 필요 DTMF 모드에서는 무시됨 | [4.5](https://www.w3.org/TR/speech-grammar/#S4.5): grammar 요소의 xml:lang 속성 | 음성 모드에 필요 DTMF 모드에서는 무시됨 | SRGS | 
| Mode | 선택 사항 | [4.6](https://www.w3.org/TR/speech-grammar/#S4.6): grammar 요소의 mode 속성 | 선택 사항 | SRGS | 
| 루트 규칙 | 선택 사항 | [4.7](https://www.w3.org/TR/speech-grammar/#S4.7): grammar 요소의 root 속성 | 필수 | SRGS | 
| 태그 형식 | 선택 사항 | [4.8](https://www.w3.org/TR/speech-grammar/#S4.8): grammar 요소의 tag-format 속성 | 문자열 리터럴 및 ECMAScript 지원 | SRGS, SISR | 
| 기본 URI | 선택 사항 | [4.9](https://www.w3.org/TR/speech-grammar/#S4.9): grammar 요소의 xml:base 속성 | 선택 사항 | SRGS | 
| 발음 어휘 | 선택 사항, 복수 허용 | [4.10](https://www.w3.org/TR/speech-grammar/#S4.`0): lexicon 요소 | 지원되지 않음 | SRGS, PLS | 
| Metadata | 선택 사항, 복수 허용 | [4.11.1](https://www.w3.org/TR/speech-grammar/#S4.11.1): meta 요소 | 필수 | SRGS | 
| XML 메타데이터 | 선택 사항, XML만 해당 | [4.11.2](https://www.w3.org/TR/speech-grammar/#S4.11.2): metadata 요소 | 선택 사항 | SRGS | 
| 태그 | 선택 사항, 복수 허용 | [4.12](https://www.w3.org/TR/speech-grammar/#S4.12): tag 요소 | 글로벌 태그는 지원되지 않음 | SRGS | 

**예제**

```
<?xml version="1.0" encoding="ISO-8859-1"?>

<!DOCTYPE grammar PUBLIC "-//W3C//DTD GRAMMAR 1.0//EN"
                  "http://www.w3.org/TR/speech-grammar/grammar.dtd">

<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xml:base="http://www.example.com/base-file-path"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US"
         version="1.0"
         mode="voice"
         root="city"
         tag-format="semantics/1.0">
```

# 지원되는 XML 요소
<a name="srgs-supported-xml"></a>

Amazon Lex V2는 사용자 지정 문법에 대해 다음과 같은 XML 요소를 지원합니다.
+ `<item>`
+ `<token>`
+ `<tag>`
+ `<one-of>`
+ `<rule-ref>`

# 토큰
<a name="srgs-tokens"></a>

다음 표에 문법 슬롯 유형이 지원하는 토큰 사양이 나와 있습니다. 자세한 내용은 *음성 인식 문법 사양 버전 1* W3C 권장 사항의 [토큰](https://www.w3.org/TR/speech-grammar/#S2.1)을 참조하세요.


| 토큰 유형 | 예제 | 지원 여부 | 
| --- | --- | --- | 
| 따옴표가 없는 단일 토큰 | hello | 예 | 
| 따옴표가 없는 단일 토큰: 비 알파벳 | 2 | 예 | 
| 따옴표가 있는 단일 토큰, 공백 없음 | "hello" | 예, 토큰이 한 개만 포함된 경우에는 큰따옴표를 사용하지 마세요. | 
| 공백으로 구분된 두 개의 토큰 | bon voyage | 예 | 
| 공백으로 구분된 네 개의 토큰 | this is a test | 예 | 
| 따옴표가 있는 단일 토큰, 공백 포함 | "San Francisco | 아니요 | 
| <token> 태그 속의 단일 XML 토큰 | <token>San Francisco</token> | 아니요(따옴표가 있는 단일 토큰과 동일, 공백 포함) | 

**참고**
+ *따옴표가 있는 단일 토큰, 공백 포함* – 사양에 따르면 큰따옴표로 묶인 단어를 단일 토큰으로 취급해야 합니다. Amazon Lex V2는 이를 공백으로 구분된 토큰으로 취급합니다.
+ *<token> 속의 단일 XML 토큰* – 사양에 따르면 <token>으로 구분된 단어는 하나의 토큰을 나타내야 합니다. Amazon Lex V2는 이를 공백으로 구분된 토큰으로 취급합니다.
+ Amazon Lex V2에서는 문법에서 두 사용법 중 하나가 발견되면 검증 오류가 발생합니다.

**예제**

```
<rule id="state" scope="public">
    <one-of>
        <item>FL</item>
        <item>MA</item>
        <item>NY</item>
    </one-of>
</rule>
```

# 규칙 참조
<a name="srgs-rule-reference"></a>

다음 표에는 문법 문서 내에서 사용할 수 있는 다양한 형태의 규칙 참조가 요약되어 있습니다. 자세한 내용은 *음성 인식 문법 사양 버전 1* W3C 권장 사항의 [규칙 참조](https://www.w3.org/TR/speech-grammar/#S2.2)를 참조하세요.


| 참조 유형 | XML 양식 | 지원됨 | 
| --- | --- | --- | 
| [2.2.1](https://www.w3.org/TR/speech-grammar/#S2.2.1) 명시적 로컬 규칙 참조 | <ruleref uri="\$1rulename"/> | 예 | 
| [ 2.2.2 ](https://www.w3.org/TR/speech-grammar/#S2.2.2) [URI](https://www.w3.org/TR/speech-grammar/#term-uri)로 식별되는 문법의 명명된 규칙에 대한 명시적 참조 | <ruleref uri="grammarURI\$1rulename"/> | 아니요 | 
| [ 2.2.2 ](https://www.w3.org/TR/speech-grammar/#S2.2.2) [URI](https://www.w3.org/TR/speech-grammar/#term-uri)로 식별되는 문법의 루트 규칙에 대한 암시적 참조 | <ruleref uri="grammarURI"/> | 아니요 | 
| [ 2.2.2 ](https://www.w3.org/TR/speech-grammar/#S2.2.2) [미디어 유형](https://www.w3.org/TR/speech-grammar/#term-media-type)이 있는 [URI](https://www.w3.org/TR/speech-grammar/#term-uri)로 식별되는 문법의 명명된 규칙에 대한 명시적 참조 | <ruleref uri="grammarURI\$1rulename" type="media-type"/> | 아니요 | 
| [ 2.2.2 ](https://www.w3.org/TR/speech-grammar/#S2.2.2) [미디어 유형](https://www.w3.org/TR/speech-grammar/#term-media-type)이 있는 [URI](https://www.w3.org/TR/speech-grammar/#term-uri)로 식별되는 문법의 루트 규칙에 대한 암시적 참조 | <ruleref uri="grammarURI" type="media-type"/> | 아니요 | 
| [ 2.2.3 ](https://www.w3.org/TR/speech-grammar/#S2.2.3) 특수 규칙 정의 | `<ruleref special="NULL"/>` `<ruleref special="VOID"/>` `<ruleref special="GARBAGE"/>` | 아니요 | 

**참고**

1. 문법 URI는 외부 URI입니다. 예를 들어 `http://grammar.example.com/world-cities.grxml`입니다.

1. 미디어 유형은 다음과 같을 수 있습니다.
   + `application/srgs+xml`
   + `text/plain`

**예제**

```
<rule id="city" scope="public">
    <one-of>
        <item>Boston</item>
        <item>Philadelphia</item>
        <item>Fargo</item>
    </one-of>
</rule>

<rule id="state" scope="public">
    <one-of>
        <item>FL</item>
        <item>MA</item>
        <item>NY</item>
    </one-of>
</rule>

<!-- "Boston MA" -> city = Boston, state = MA -->
<rule id="city_state" scope="public">
    <ruleref uri="#city"/> <ruleref uri="#state"/>
</rule>
```

# 시퀀스 및 캡슐화
<a name="srgs-sequence"></a>

다음 예제에서는 지원되는 시퀀스를 보여줍니다. 자세한 내용은 *음성 인식 문법 사양 버전 1* W3C 권장 사항의 [시퀀스 및 캡슐화](https://www.w3.org/TR/speech-grammar/#S2.3)를 참조하세요.

**예제**

```
<!-- sequence of tokens -->
this is a test

<!--sequence of rule references-->
<ruleref uri="#action"/> <ruleref uri="#object"/>

<!--sequence of tokens and rule references-->
the <ruleref uri="#object"/> is <ruleref uri="#color"/>

<!-- sequence container -->
<item>fly to <ruleref uri="#city"/> </item>
```

# 반복
<a name="srgs-repeats"></a>

다음 표에는 지원되는 규칙 반복 확장이 나와 있습니다. 자세한 내용은 *음성 인식 문법 사양 버전 1* W3C 권장 사항의 [반복](https://www.w3.org/TR/speech-grammar/#S2.5)을 참조하세요.


| XML 양식예제 | 동작 | 지원 여부 | 
| --- | --- | --- | 
| *repeat="n"* repeat="6" | 포함된 표현식이 정확히 “n”번 반복됩니다. “n”은 “0"이거나 양의 정수여야 합니다. | 예 | 
| *repeat="m-n"* repeat="4-6" | 포함된 확장은 “m”에서 “n”회 사이에서 반복됩니다 (포함). “m”과 “n”은 모두 “0"이거나 양의 정수여야 하고, “m”은 “n”보다 작거나 같아야 합니다. | 예 | 
| *repeat="m-"* repeat="3-" | 포함된 확장이 “m”번 이상(포함) 반복됩니다. “m”은 “0"이거나 양의 정수여야 합니다. 예를 들어, “3-”는 포함된 확장이 세 번, 네 번, 다섯 번 또는 그 이상 발생할 수 있음을 선언합니다. | 예 | 
| *repeat="0-1"*  | 포함된 확장은 선택 사항입니다. | 예 | 
| <item repeat="2-4" repeat-prob="0.8"> |   | 아니요 | 

# 언어
<a name="srgs-language"></a>

다음 논의는 문법에 적용되는 언어 식별자에 적용됩니다. 자세한 내용은 *음성 인식 문법 사양 버전 1* W3C 권장 사항의 [언어](https://www.w3.org/TR/speech-grammar/#S2.7)를 참조하세요.

기본적으로 문법은 [문법 헤더](https://www.w3.org/TR/speech-grammar/#S4.1)의 언어 선언에 [언어 식별자](https://www.w3.org/TR/speech-grammar/#term-language)가 제공된 단일 언어 문서입니다. 달리 선언되지 않는 한 해당 문법 내의 모든 토큰은 **문법의 언어에 따라 처리됩니다**. 문법 수준의 언어 선언은 **지원되지 않습니다**.

이 예에서 다음과 같이 합니다.

1. Amazon Lex V2는 “en-US” 언어에 대한 문법 헤더 선언을 **지원합니다**.

1. 항목 수준 언어 첨부(*빨간색*으로 강조 표시)는 **지원되지 않습니다**. Amazon Lex V2에서는 언어 첨부가 헤더 선언과 다른 경우 검증 오류가 발생합니다.

```
<?xml version="1.0" encoding="ISO-8859-1"?>

<!DOCTYPE grammar PUBLIC "-//W3C//DTD GRAMMAR 1.0//EN"
                  "http://www.w3.org/TR/speech-grammar/grammar.dtd">

<!-- the default grammar language is US English -->
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0">

  <!--
     single language attachment to tokens
     "yes" inherits US English language
     "oui" is Canadian French language
  -->
  <rule id="yes">
    <one-of>
      <item>yes</item>
      <item xml:lang="fr-CA">oui</item>
    </one-of>
  </rule>

  <!-- Single language attachment to an expansion -->
  <rule id="people1">
    <one-of xml:lang="fr-CA">
      <item>Michel Tremblay</item>
      <item>André Roy</item>
    </one-of>
  </rule>
</grammar>
```

# Tags
<a name="srgs-tags"></a>

다음 설명은 문법에 정의된 태그에 적용됩니다. 자세한 내용은 *음성 인식 문법 사양 버전 1* W3C 권장 사항의 [태그](https://www.w3.org/TR/speech-grammar/#S2.6)를 참조하세요.

SRGS 사양에 따라 태그는 다음과 같은 방식으로 정의될 수 있습니다.

1. [헤더 선언](srgs-header.md)에 설명된 대로 헤더 선언의 일부로.

1. *<rule>* 정의의 일부로.

다음 태그 형식이 지원됩니다.
+ `semantics/1.0`(SISR, ECMAScript)
+ `semantics/1.0-literals`(SISR 문자열 리터럴)

다음 태그 형식은 지원되지 않습니다.
+ `swi-semantics/1.0`(뉘앙스 전용)

**예제**

```
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xml:base="http://www.example.com/base-file-path"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US"
         version="1.0"
         mode="voice"
         root="city"
         tag-format="semantics/1.0-literals">
    <rule id="no">
        <one-of>
            <item>no</item>
            <item>nope</item>
            <item>no way</item>
        </one-of>
        <tag>no</tag>
    </rule>
</grammar>
```

# 가중치
<a name="grammar-weights"></a>

요소에 *가중치* 속성을 추가할 수 있습니다. 가중치는 음성 인식 중에 항목의 문구가 부스팅되는 정도를 나타내는 양의 부동 소수점 값입니다. 자세한 내용은 음성 인식 문법 사양 버전 1 W3C 권장 사항의 [가중치](https://www.w3.org/TR/speech-grammar/)를 참조하세요.

가중치는 0보다 크고 10보다 작거나 같아야 하며 소수점 한 자리만 사용할 수 있습니다. 가중치가 0보다 크고 1보다 작으면 문구가 음으로 부스팅됩니다. 가중치가 1보다 크고 10보다 작거나 같으면 문구가 양으로 부스팅됩니다. 가중치가 1이면 가중치를 전혀 주지 않는 것과 같으며, 해당 문구는 부스팅되지 않습니다.

음성 인식 성능 향상을 위해 항목에 적절한 가중치를 할당하는 것은 어려운 작업입니다. 가중치를 할당할 때 따를 수 있는 몇 가지 팁은 다음과 같습니다.
+ 항목 가중치를 할당되지 않은 문법으로 시작하세요.
+ 음성에서 자주 잘못 식별하는 패턴이 무엇인지 확인해 보세요.
+ 음성 인식 성능이 향상되고 회귀가 없을 때까지 가중치에 다른 값을 적용하세요.

**예제 1**.

예를 들어 공항에 대한 문법이 있는데 *New York*이 *Newark*로 잘못 인식되는 경우가 많다면 가중치 5를 할당하여 New York을 양으로 부스팅시킬 수 있습니다.

```
<rule> id="airport">
    <one-of>
        <item>
            Boston
            <tag>out="Boston"</tag>
        </item>
        <item weight="5">
            New York
            <tag>out="New York"</tag>
        </item>
        <item>
            Newark
            <tag>out="Newark"</tag>
        </item>
    </one-of>
</rule>
```

**예제 2**.

예를 들어, 항공사 예약 코드의 문법은 영어 알파벳으로 시작하고 그 뒤에 세 자리 숫자가 오는 경우를 예로 들 수 있습니다. 예약 코드는 B 또는 D로 시작할 가능성이 높지만 B는 P로, D는 T로 잘못 식별되는 경우가 많습니다. B와 D를 양으로 부스팅시킬 수 있습니다.

```
<rule> id="alphabet">
    <one-of>
        <item>A<tag>out.letters+='A';</tag></item>
        <item weight="3.5">B<tag>out.letters+='B';</tag></item>
        <item>C<tag>out.letters+='C';</tag></item>
        <item weight="2.9">D<tag>out.letters+='D';</tag></item>
        <item>E<tag>out.letters+='E';</tag></item>
        <item>F<tag>out.letters+='F';</tag></item>
        <item>G<tag>out.letters+='G';</tag></item>
        <item>H<tag>out.letters+='H';</tag></item>
        <item>I<tag>out.letters+='I';</tag></item>
        <item>J<tag>out.letters+='J';</tag></item>
        <item>K<tag>out.letters+='K';</tag></item>
        <item>L<tag>out.letters+='L';</tag></item>
        <item>M<tag>out.letters+='M';</tag></item>
        <item>N<tag>out.letters+='N';</tag></item>
        <item>O<tag>out.letters+='O';</tag></item>
        <item>P<tag>out.letters+='P';</tag></item>
        <item>Q<tag>out.letters+='Q';</tag></item>
        <item>R<tag>out.letters+='R';</tag></item>
        <item>S<tag>out.letters+='S';</tag></item>
        <item>T<tag>out.letters+='T';</tag></item>
        <item>U<tag>out.letters+='U';</tag></item>
        <item>V<tag>out.letters+='V';</tag></item>
        <item>W<tag>out.letters+='W';</tag></item>
        <item>X<tag>out.letters+='X';</tag></item>
        <item>Y<tag>out.letters+='Y';</tag></item>
        <item>Z<tag>out.letters+='Z';</tag></item>
    </one-of>
</rule>
```

# 스크립트 형식
<a name="grammar-ecmascript-spec"></a>

Amazon Lex V2는 문법 정의를 위해 다음과 같은 ECMAScript 기능을 지원합니다.

Amazon Lex V2는 문법에 태그를 지정할 때 다음과 같은 ECMAScript 기능을 지원합니다. 문법에 ECMAScript 태그가 사용되는 경우 `tag-format`을 `semantics/1.0`으로 보내야 합니다. 자세한 내용은 [ECMA-262 ECMAScript 2021 언어 사양](https://www.ecma-international.org/publications-and-standards/standards/ecma-262/)을 참조하세요.

```
<grammar version="1.0"
xmlns="http://www.w3.org/2001/06/grammar"
xml:lang="en-US"
tag-format="semantics/1.0"
root="card_number">
```

**Topics**
+ [변수 명령문](ecma-variable.md)
+ [Expressions](ecma-expression.md)
+ [IF 문](ecma-if.md)
+ [Switch 문](ecma-switch.md)
+ [함수 선언](ecma-function.md)
+ [Iteration 문](ecma-iteration.md)
+ [Block 문](ecma-block.md)
+ [설명](ecma-comments.md)
+ [지원되지 않는 명령문](ecma-unsupported.md)

이 문서에는 ECMAScript 표준의 자료가 포함되어 있습니다 ([https://www.ecma-international.org/publications-and-standards/standards/ecma-262/](https://www.ecma-international.org/publications-and-standards/standards/ecma-262/)에서 제공). ECMAScript 언어 사양 문서는 다음 라이선스에 따라 Ecma International에서 사용할 수 있습니다.

## 라이선스 텍스트
<a name="ecma-license"></a>

© 2020 Ecma International

위의 저작권 고지 및 본 저작권 사용권 및 고지 사항이 그러한 모든 사본 및 파생 저작물에 포함되어 있는 경우, 이 문서의 일부 또는 전부를 복사, 출판 및 배포할 수 있으며, 이 문서의 일부 파생 저작물은 작성, 복사, 출판 및 배포될 수 있습니다. 본 저작권 라이선스 및 면책 조항에 따라 허용되는 유일한 파생 저작물은 다음과 같습니다.

(i) 해설이나 설명을 제공할 목적으로 이 문서의 전체 또는 일부를 포함하는 저작물(예: 문서의 주석이 달린 버전) 

(ii) 접근성을 제공하는 기능을 통합할 목적으로 이 문서의 전체 또는 일부를 통합하는 저작물 

(iii) 이 문서를 영어 이외의 다른 언어 및 다른 형식으로 번역 

(iv) 해당 기능을 구현(예: 전체 또는 부분 복사하여 붙여넣기)하여 표준 준수 제품에 이 사양을 활용하는 저작물.

그러나 이 문서 자체의 내용은 영어 이외의 언어 또는 다른 형식으로 번역하는 데 필요한 경우를 제외하고는 저작권 표시 또는 Ecma International에 대한 참조 제거를 포함한 어떠한 방식으로도 수정할 수 없습니다.

Ecma International 문서의 공식 버전은 Ecma International 웹사이트에 있는 영어 버전입니다. 번역된 버전과 공식 버전 사이에 불일치가 있는 경우 공식 버전이 우선합니다.

위에 부여된 제한된 권한은 영구적이며 Ecma International이나 그 후임자 또는 양수인이 취소하지 않습니다. 이 문서와 여기에 포함된 정보는 “있는 그대로” 제공되며 ECMA INTERNATIONAL은 본 문서에 포함된 정보의 사용이 소유권을 침해하지 않을 것이라는 보증이나 상품성 또는 특정 목적에의 적합성에 대한 묵시적 보증을 포함하되 이에 국한되지 않는 모든 명시적 또는 묵시적 보증을 부인합니다.”

# 변수 명령문
<a name="ecma-variable"></a>

변수 명령문은 하나 이상의 변수를 정의합니다.

```
var x = 10;
var x = 10, var y = <expression>;
```

# Expressions
<a name="ecma-expression"></a>

표현식 문자열을 추가하여 Amazon Lex V2에서 함수를 수행할 수 있습니다. 이 표에는 SRGS 표현식에 사용할 수 있는 구문과 예제가 적혀 있습니다.


| 표현식 유형 | 구문 | 예제 | 지원 여부 | 
| --- | --- | --- | --- | 
| 정규식 리터럴 | 유효한 [정규식 특수 문자](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions)를 포함하는 문자열 리터럴 | <pre>"^\d\.$"</pre> | 아니요 | 
| 함수 | function functionName(parameters) \$1 functionBody\$1 | <pre>var x = function calc() {<br />    return 10;<br />}</pre> | 아니요 | 
| Delete | delete expression | <pre>delete obj.property;</pre> | 아니요 | 
| Void | void expression | <pre>void (2 == '2');</pre> | 아니요 | 
| Typeof | typeof expression | <pre>typeof 42;</pre> | 아니요 | 
| Member index | expression [ expressions ] | <pre>var fruits = ["apple"];<br />fruits[0];</pre> | 예 | 
| Member dot | expression . identifier | <pre>out.value</pre> | yes | 
| 인수 | expression (arguments) | <pre>new Date('1994-10-11')</pre> | 예 | 
| Post increment | expression\$1\$1 | <pre>var x=10; x++;</pre> | 예 | 
| Post decrement | expression-- | <pre>var x=10; x--;</pre> | 예 | 
| Pre increment | \$1\$1expression | <pre>var x=10; ++x;</pre> | 예 | 
| Pre decrement | --expression | <pre>var x=10; --x;</pre> | 예 | 
| Unary plus / Unary minus | \$1expression / -expression | <pre>+x / -x;</pre> | 예 | 
| Bit not | \$1 expression | <pre>const a = 5;<br />console.log( ~a );</pre> | 예 | 
| Logical not | \$1 expression | <pre>!(a > 0 || b > 0)</pre> | 예 | 
| Multiplicative | expression ('\$1' \$1 '/' \$1 '%') expression | <pre>(x + y) * (a / b)</pre> | 예 | 
| Additive | expression ('\$1' \$1 '-') expression | <pre>(a + b) - (a - (a + b))</pre> | 예 | 
| Bit shift | expression ('<<' \$1 '>>' \$1 '>>>') expression | <pre>(a >> b) >>> c</pre> | 예 | 
| Relative | expression ('<' \$1 '>' \$1 '<=' \$1 '>=') expression | <pre>if (a > b) { ... }</pre> | 예 | 
| 있음 | expression in expression | <pre>fruits[0] in otherFruits;</pre> | 예 | 
| Equality | expression ('==' \$1 '\$1=' \$1 '===' \$1 '\$1===') expression | <pre>if (a == b) { ... }</pre> | 예 | 
| Bit and / xor / or | expression ('&' \$1 '^' \$1 '\$1') expression | <pre>a & b / a ^ b / a | b</pre> | 예 | 
| Logical and / or | expression ('&&' \$1 '\$1\$1') expression | <pre>if (a && (b ||c)) { ...}</pre> | 예 | 
| 3진  | expression ? expression : expression | <pre>a > b ? obj.prop : 0</pre> | 예 | 
| 대입 | expression = expression | <pre>out.value = "string";</pre> | 예 | 
| Assignment operator | expression ('\$1=' \$1 '/=' \$1 '\$1=' \$1 '-=' \$1 '%=') expression  | <pre>a *= 10;</pre> | 예 | 
| Assignment bitwise operator | expression ('<<=' \$1 '>>=' \$1 '>>>=' \$1 '&=' \$1 '^=' \$1 '\$1=') expression | <pre>a <<= 10;</pre> | 예 | 
| 식별자 | identifierSequence 여기서 identifierSequence는 [유효한 문자](https://developer.mozilla.org/en-US/docs/Glossary/Identifier)의 시퀀스임 | <pre>fruits=[10, 20, 30];</pre> | 예 | 
| Null literal | null | <pre>x = null;</pre> | 예 | 
| Boolean literal | true \$1 false | <pre>x = true;</pre> | 예 | 
| String literal | 'string' / "string" | <pre>a = 'hello',<br />b = "world";</pre> | 예 | 
| Decimal literal | integer [.] digits [exponent] | <pre>111.11 e+12</pre> | 예 | 
| Hex literal | 0 (x \$1 X)[0-9a-fA-F] | <pre>0x123ABC</pre> | 예 | 
| Octal literal | O [0-7] | <pre>"O51"</pre> | 예 | 
| Array literal | [ expression, ... ] | <pre>v = [a, b, c];</pre> | 예 | 
| Object literal | \$1property: value, ...\$1 | <pre>out = {value: 1, flag: false};</pre> | 예 | 
| Parenthesized | ( expressions ) | <pre>x + (x + y)</pre> | 예 | 

# IF 문
<a name="ecma-if"></a>

if 문을 추가하여 Amazon Lex V2에서 함수를 수행할 수 있습니다. 이 예제는 SRGS 표현식에 사용할 수 있는 구문을 보여줍니다.

```
if (expressions) {
    statements;
} else {
    statements;
}
```

**참고:** 앞의 예에서 `expressions` 및 `statements`는 이 문서에서 지원되는 것 중 하나여야 합니다.

# Switch 문
<a name="ecma-switch"></a>

switch 문을 추가하여 Amazon Lex V2에서 함수를 수행할 수 있습니다. 이 예제는 SRGS 표현식에 사용할 수 있는 구문을 보여줍니다.

```
switch (expression) {
    case (expression):
     statements
     .
     .
     .
   default:
      statements
}
```

**참고:** 앞의 예에서 `expressions` 및 `statements`는 이 문서에서 지원되는 것 중 하나여야 합니다.

# 함수 선언
<a name="ecma-function"></a>

함수 선언을 추가하여 Amazon Lex V2에서 함수를 수행할 수 있습니다. 이 예제는 SRGS 표현식에 사용할 수 있는 구문을 보여줍니다.

```
function functionIdentifier([parameterList, ...]) {
     <function body>
}
```

# Iteration 문
<a name="ecma-iteration"></a>

Iteration 문은 다음 중 하나가 될 수 있습니다.

```
// Do..While statement
do {
   statements
} while (expressions)


// While Loop
while (expressions) {
   statements
}

// For Loop
for ([initialization]; [condition]; [final-expression])
   statement

// For..In
for (variable in object) {
  statement
}
```

# Block 문
<a name="ecma-block"></a>

명령문 블록을 추가하여 Amazon Lex V2에서 함수를 수행할 수 있습니다. 이 예제는 SRGS 표현식에 사용할 수 있는 구문을 보여줍니다.

```
{
   statements
}

// Example
{
    x = 10;
   if (x > 10) {
     console.log("greater than 10");
   }
}
```

**참고:** 앞의 예에서 `statements`에 제공된 명령문은 이 문서에서 지원되는 것 중 하나여야 합니다.

# 설명
<a name="ecma-comments"></a>

Amazon Lex V2에 설명을 추가할 수 있습니다. 이 예제는 SRGS 표현식에 사용할 수 있는 구문을 보여줍니다.

```
// Single Line Comments
"// <comment>"

// Multineline comments
/**
<comment>
**/
```

# 지원되지 않는 명령문
<a name="ecma-unsupported"></a>

Amazon Lex V2는 다음 ECMAScript 기능을 지원하지 않습니다.

**Topics**
+ [Empty 문](#ecma-unsupported-empty)
+ [Continue 문](#ecma-unsupported-continue)
+ [Break 문](#ecma-unsupported-break)
+ [Return 문](#ecma-unsupported-return)
+ [Throw 문](#ecma-unsupported-throw)
+ [Try 문](#ecma-unsupported-try)
+ [Debugger 문](#ecma-unsupported-debugger)
+ [Labeled 문](#ecma-unsupported-labelled)
+ [클래스 선언](#ecma-unsupported-class)

## Empty 문
<a name="ecma-unsupported-empty"></a>

Empty 문은 명령문을 제공하지 않는 데 사용됩니다. 다음은 Empty 문의 구문입니다.

```
;
```

## Continue 문
<a name="ecma-unsupported-continue"></a>

레이블이 없는 Continue 문은 [Iteration 문](ecma-iteration.md)와 함께 지원됩니다. 레이블이 있는 Continue 문은 지원되지 않습니다.

```
// continue with label
// this allows the program to jump to a
// labelled statement (see labelled statement below)
continue <label>;
```

## Break 문
<a name="ecma-unsupported-break"></a>

레이블이 없는 Break 문은 [Iteration 문](ecma-iteration.md)와 함께 지원됩니다. 레이블이 있는 Break 문은 지원되지 않습니다.

```
// break with label
// this allows the program to break out of a
// labelled statement (see labelled statement below)
break <label>;
```

## Return 문
<a name="ecma-unsupported-return"></a>

```
return expression;
```

## Throw 문
<a name="ecma-unsupported-throw"></a>

Throw 문은 사용자 정의 예외를 발생시키는 데 사용됩니다.

```
throw expression;
```

## Try 문
<a name="ecma-unsupported-try"></a>

```
try {
  statements
}
catch (expression) {
  statements
}
finally {
  statements
}
```

## Debugger 문
<a name="ecma-unsupported-debugger"></a>

Debugger 문은 환경에서 제공하는 디버깅 기능을 간접적으로 호출하는 데 사용됩니다.

```
debugger;
```

## Labeled 문
<a name="ecma-unsupported-labelled"></a>

Labeled 문은 `break` 또는 `continue` 문과 함께 사용할 수 있습니다.

```
label:
   statements


// Example
let str = '';

loop1:
for (let i = 0; i < 5; i++) {
  if (i === 1) {
    continue loop1;
  }
  str = str + i;
}

console.log(str);
```

## 클래스 선언
<a name="ecma-unsupported-class"></a>

```
class Rectangle {
  constructor(height, width) {
    this.height = height;
    this.width = width;
  }
}
```

# 업계 문법
<a name="grammar-industry"></a>

*업계 문법*은 [문법 슬롯 유형](https://docs.aws.amazon.com/lexv2/latest/dg/building-srgs.html)과 함께 사용할 수 있는 XML 파일 세트입니다. 이를 사용하여 대화형 음성 응답 워크플로를 Amazon Lex V2로 마이그레이션할 때 일관된 최종 사용자 경험을 신속하게 제공할 수 있습니다. 금융 서비스, 보험, 통신 등 세 가지 영역에 걸쳐 사전 구축된 다양한 문법 중에서 선택할 수 있습니다. 자체 문법의 시작점으로 사용할 수 있는 일반적인 문법 세트도 있습니다.

 문법에는 정보를 수집하는 규칙과 의미론적 해석을 위한 [ECMAScript](https://docs.aws.amazon.com/lexv2/latest/dg/grammar-ecmascript-spec.html) 태그가 포함되어 있습니다.

## 금융 서비스용 문법([다운로드](samples/financial-grammars.zip))
<a name="financial-services-grammars"></a>

금융 서비스에서는 계좌 및 라우팅 번호, 신용 카드 및 대출 번호, 신용 점수, 계좌 개설 및 폐쇄일, 주민등록번호와 같은 문법이 지원됩니다.

### 계좌 번호
<a name="financial-account"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">


        <!-- Test Cases

        Grammar will support the following inputs:

            Scenario 1:
                Input: My account number is A B C 1 2 3 4
                Output: ABC1234

            Scenario 2:
                Input: My account number is 1 2 3 4 A B C
                Output: 1234ABC

            Scenario 3:
                Input: Hmm My account number is 1 2 3 4 A B C 1
                Output: 123ABC1
        -->

        <rule id="main" scope="public">
            <tag>out=""</tag>
            <item><ruleref uri="#alphanumeric"/><tag>out += rules.alphanumeric.alphanum;</tag></item>
            <item repeat="0-1"><ruleref uri="#alphabets"/><tag>out += rules.alphabets.letters;</tag></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits.numbers</tag></item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
            <one-of>
                <item repeat="0-1">account number is</item>
                <item repeat="0-1">Account Number</item>
                <item repeat="0-1">Here is my Account Number </item>
                <item repeat="0-1">Yes, It is</item>
                <item repeat="0-1">Yes It is</item>
                <item repeat="0-1">Yes It's</item>
                <item repeat="0-1">My account Id is</item>
                <item repeat="0-1">This is the account Id</item>
                <item repeat="0-1">account Id</item>
            </one-of>
        </rule>

        <rule id="hesitation">
          <one-of>
             <item>Hmm</item>
             <item>Mmm</item>
             <item>My</item>
          </one-of>
        </rule>

        <rule id="alphanumeric" scope="public">
            <tag>out.alphanum=""</tag>
            <item><ruleref uri="#alphabets"/><tag>out.alphanum += rules.alphabets.letters;</tag></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out.alphanum += rules.digits.numbers</tag></item>
        </rule>

        <rule id="alphabets">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.letters=""</tag>
            <tag>out.firstOccurence=""</tag>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out.firstOccurence += rules.digits.numbers; out.letters += out.firstOccurence;</tag></item>
            <item repeat="1-">
                <one-of>
                    <item>A<tag>out.letters+='A';</tag></item>
                    <item>B<tag>out.letters+='B';</tag></item>
                    <item>C<tag>out.letters+='C';</tag></item>
                    <item>D<tag>out.letters+='D';</tag></item>
                    <item>E<tag>out.letters+='E';</tag></item>
                    <item>F<tag>out.letters+='F';</tag></item>
                    <item>G<tag>out.letters+='G';</tag></item>
                    <item>H<tag>out.letters+='H';</tag></item>
                    <item>I<tag>out.letters+='I';</tag></item>
                    <item>J<tag>out.letters+='J';</tag></item>
                    <item>K<tag>out.letters+='K';</tag></item>
                    <item>L<tag>out.letters+='L';</tag></item>
                    <item>M<tag>out.letters+='M';</tag></item>
                    <item>N<tag>out.letters+='N';</tag></item>
                    <item>O<tag>out.letters+='O';</tag></item>
                    <item>P<tag>out.letters+='P';</tag></item>
                    <item>Q<tag>out.letters+='Q';</tag></item>
                    <item>R<tag>out.letters+='R';</tag></item>
                    <item>S<tag>out.letters+='S';</tag></item>
                    <item>T<tag>out.letters+='T';</tag></item>
                    <item>U<tag>out.letters+='U';</tag></item>
                    <item>V<tag>out.letters+='V';</tag></item>
                    <item>W<tag>out.letters+='W';</tag></item>
                    <item>X<tag>out.letters+='X';</tag></item>
                    <item>Y<tag>out.letters+='Y';</tag></item>
                    <item>Z<tag>out.letters+='Z';</tag></item>
                </one-of>
            </item>
        </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.numbers=""</tag>
            <item repeat="1-10">
                <one-of>
                    <item>0<tag>out.numbers+=0;</tag></item>
                    <item>1<tag>out.numbers+=1;</tag></item>
                    <item>2<tag>out.numbers+=2;</tag></item>
                    <item>3<tag>out.numbers+=3;</tag></item>
                    <item>4<tag>out.numbers+=4;</tag></item>
                    <item>5<tag>out.numbers+=5;</tag></item>
                    <item>6<tag>out.numbers+=6;</tag></item>
                    <item>7<tag>out.numbers+=7;</tag></item>
                    <item>8<tag>out.numbers+=8;</tag></item>
                    <item>9<tag>out.numbers+=9;</tag></item>
                </one-of>
            </item>
        </rule>
</grammar>
```

### 송금 번호
<a name="financial-routing"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="digits"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: My routing number is 1 2 3 4 5 6 7 8 9
                 Output: 123456789

             Scenario 2:
                 Input: routing number 1 2 3 4 5 6 7 8 9
                 Output: 123456789

         -->

        <rule id="digits">
            <tag>out=""</tag>
            <item><ruleref uri="#singleDigit"/><tag>out += rules.singleDigit.digit;</tag></item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
           <one-of>
              <item repeat="0-1">My routing number</item>
              <item repeat="0-1">Routing number of</item>
              <item repeat="0-1">The routing number is</item>
           </one-of>
        </rule>

        <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

        <rule id="singleDigit">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.digit=""</tag>
            <item repeat="16">
                <one-of>
                    <item>0<tag>out.digit+=0;</tag></item>
                    <item>zero<tag>out.digit+=0;</tag></item>
                    <item>1<tag>out.digit+=1;</tag></item>
                    <item>one<tag>out.digit+=1;</tag></item>
                    <item>2<tag>out.digit+=2;</tag></item>
                    <item>two<tag>out.digit+=2;</tag></item>
                    <item>3<tag>out.digit+=3;</tag></item>
                    <item>three<tag>out.digit+=3;</tag></item>
                    <item>4<tag>out.digit+=4;</tag></item>
                    <item>four<tag>out.digit+=4;</tag></item>
                    <item>5<tag>out.digit+=5;</tag></item>
                    <item>five<tag>out.digit+=5;</tag></item>
                    <item>6<tag>out.digit+=6;</tag></item>
                    <item>six<tag>out.digit+=5;</tag></item>
                    <item>7<tag>out.digit+=7;</tag></item>
                    <item>seven<tag>out.digit+=7;</tag></item>
                    <item>8<tag>out.digit+=8;</tag></item>
                    <item>eight<tag>out.digit+=8;</tag></item>
                    <item>9<tag>out.digit+=9;</tag></item>
                    <item>nine<tag>out.digit+=9;</tag></item>
                </one-of>
            </item>
        </rule>
</grammar>
```

### 신용 카드 번호
<a name="financial-ccn"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="digits"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: My credit card number is 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7
                 Output: 1234567891234567

             Scenario 2:
                 Input: card number 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7
                 Output: 1234567891234567

         -->

        <rule id="digits">
            <tag>out=""</tag>
            <item><ruleref uri="#singleDigit"/><tag>out += rules.singleDigit.digit;</tag></item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
           <one-of>
              <item repeat="0-1">My credit card number is</item>
              <item repeat="0-1">card number</item>
           </one-of>
        </rule>

        <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

        <rule id="singleDigit">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.digit=""</tag>
            <item repeat="16">
                <one-of>
                    <item>0<tag>out.digit+=0;</tag></item>
                    <item>zero<tag>out.digit+=0;</tag></item>
                    <item>1<tag>out.digit+=1;</tag></item>
                    <item>one<tag>out.digit+=1;</tag></item>
                    <item>2<tag>out.digit+=2;</tag></item>
                    <item>two<tag>out.digit+=2;</tag></item>
                    <item>3<tag>out.digit+=3;</tag></item>
                    <item>three<tag>out.digit+=3;</tag></item>
                    <item>4<tag>out.digit+=4;</tag></item>
                    <item>four<tag>out.digit+=4;</tag></item>
                    <item>5<tag>out.digit+=5;</tag></item>
                    <item>five<tag>out.digit+=5;</tag></item>
                    <item>6<tag>out.digit+=6;</tag></item>
                    <item>six<tag>out.digit+=5;</tag></item>
                    <item>7<tag>out.digit+=7;</tag></item>
                    <item>seven<tag>out.digit+=7;</tag></item>
                    <item>8<tag>out.digit+=8;</tag></item>
                    <item>eight<tag>out.digit+=8;</tag></item>
                    <item>9<tag>out.digit+=9;</tag></item>
                    <item>nine<tag>out.digit+=9;</tag></item>
                </one-of>
            </item>
        </rule>
</grammar>
```

### 대출 ID
<a name="financial-loan"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">


        <!-- Test Cases

        Grammar will support the following inputs:

            Scenario 1:
                Input: My loan Id is A B C 1 2 3 4
                Output: ABC1234
        -->

        <rule id="main" scope="public">
            <tag>out=""</tag>
            <item><ruleref uri="#alphanumeric"/><tag>out += rules.alphanumeric.alphanum;</tag></item>
            <item repeat="0-1"><ruleref uri="#alphabets"/><tag>out += rules.alphabets.letters;</tag></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits.numbers</tag></item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
            <one-of>
                <item repeat="0-1">my loan number is</item>
                <item repeat="0-1">The loan number</item>
                <item repeat="0-1">The loan is </item>
                <item repeat="0-1">The number is</item>
                <item repeat="0-1">loan number</item>
                <item repeat="0-1">loan number of</item>
                <item repeat="0-1">loan Id is</item>
                <item repeat="0-1">My loan Id is</item>
            </one-of>
        </rule>

        <rule id="hesitation">
          <one-of>
             <item>Hmm</item>
             <item>Mmm</item>
             <item>My</item>
          </one-of>
        </rule>

        <rule id="alphanumeric" scope="public">
            <tag>out.alphanum=""</tag>
            <item><ruleref uri="#alphabets"/><tag>out.alphanum += rules.alphabets.letters;</tag></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out.alphanum += rules.digits.numbers</tag></item>
        </rule>

        <rule id="alphabets">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.letters=""</tag>
            <tag>out.firstOccurence=""</tag>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out.firstOccurence += rules.digits.numbers; out.letters += out.firstOccurence;</tag></item>
            <item repeat="1-">
                <one-of>
                    <item>A<tag>out.letters+='A';</tag></item>
                    <item>B<tag>out.letters+='B';</tag></item>
                    <item>C<tag>out.letters+='C';</tag></item>
                    <item>D<tag>out.letters+='D';</tag></item>
                    <item>E<tag>out.letters+='E';</tag></item>
                    <item>F<tag>out.letters+='F';</tag></item>
                    <item>G<tag>out.letters+='G';</tag></item>
                    <item>H<tag>out.letters+='H';</tag></item>
                    <item>I<tag>out.letters+='I';</tag></item>
                    <item>J<tag>out.letters+='J';</tag></item>
                    <item>K<tag>out.letters+='K';</tag></item>
                    <item>L<tag>out.letters+='L';</tag></item>
                    <item>M<tag>out.letters+='M';</tag></item>
                    <item>N<tag>out.letters+='N';</tag></item>
                    <item>O<tag>out.letters+='O';</tag></item>
                    <item>P<tag>out.letters+='P';</tag></item>
                    <item>Q<tag>out.letters+='Q';</tag></item>
                    <item>R<tag>out.letters+='R';</tag></item>
                    <item>S<tag>out.letters+='S';</tag></item>
                    <item>T<tag>out.letters+='T';</tag></item>
                    <item>U<tag>out.letters+='U';</tag></item>
                    <item>V<tag>out.letters+='V';</tag></item>
                    <item>W<tag>out.letters+='W';</tag></item>
                    <item>X<tag>out.letters+='X';</tag></item>
                    <item>Y<tag>out.letters+='Y';</tag></item>
                    <item>Z<tag>out.letters+='Z';</tag></item>
                </one-of>
            </item>
        </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.numbers=""</tag>
            <item repeat="1-10">
                <one-of>
                    <item>0<tag>out.numbers+=0;</tag></item>
                    <item>1<tag>out.numbers+=1;</tag></item>
                    <item>2<tag>out.numbers+=2;</tag></item>
                    <item>3<tag>out.numbers+=3;</tag></item>
                    <item>4<tag>out.numbers+=4;</tag></item>
                    <item>5<tag>out.numbers+=5;</tag></item>
                    <item>6<tag>out.numbers+=6;</tag></item>
                    <item>7<tag>out.numbers+=7;</tag></item>
                    <item>8<tag>out.numbers+=8;</tag></item>
                    <item>9<tag>out.numbers+=9;</tag></item>
                </one-of>
            </item>
        </rule>
</grammar>
```

### 신용 점수
<a name="financial-score"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: The number is fifteen
                 Output: 15

             Scenario 2:
                 Input: My credit score is fifteen
                 Output: 15
         -->

        <rule id="main" scope="public">
            <tag>out=""</tag>
            <one-of>
              <item repeat="1"><ruleref uri="#digits"/><tag>out+= rules.digits;</tag></item>
              <item repeat="1"><ruleref uri="#teens"/><tag>out+= rules.teens;</tag></item>
              <item repeat="1"><ruleref uri="#above_twenty"/><tag>out+= rules.above_twenty;</tag></item>
            </one-of>
        </rule>

        <rule id="text">
           <one-of>
              <item repeat="0-1">Credit score is</item>
              <item repeat="0-1">Last digits are</item>
              <item repeat="0-1">The number is</item>
              <item repeat="0-1">That's</item>
              <item repeat="0-1">It is</item>
              <item repeat="0-1">My credit score is</item>
           </one-of>
        </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>0<tag>out=0;</tag></item>
                <item>1<tag>out=1;</tag></item>
                <item>2<tag>out=2;</tag></item>
                <item>3<tag>out=3;</tag></item>
                <item>4<tag>out=4;</tag></item>
                <item>5<tag>out=5;</tag></item>
                <item>6<tag>out=6;</tag></item>
                <item>7<tag>out=7;</tag></item>
                <item>8<tag>out=8;</tag></item>
                <item>9<tag>out=9;</tag></item>
                <item>one<tag>out=1;</tag></item>
                <item>two<tag>out=2;</tag></item>
                <item>three<tag>out=3;</tag></item>
                <item>four<tag>out=4;</tag></item>
                <item>five<tag>out=5;</tag></item>
                <item>six<tag>out=6;</tag></item>
                <item>seven<tag>out=7;</tag></item>
                <item>eight<tag>out=8;</tag></item>
                <item>nine<tag>out=9;</tag></item>
            </one-of>
        </rule>

        <rule id="teens">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>ten<tag>out=10;</tag></item>
                <item>eleven<tag>out=11;</tag></item>
                <item>twelve<tag>out=12;</tag></item>
                <item>thirteen<tag>out=13;</tag></item>
                <item>fourteen<tag>out=14;</tag></item>
                <item>fifteen<tag>out=15;</tag></item>
                <item>sixteen<tag>out=16;</tag></item>
                <item>seventeen<tag>out=17;</tag></item>
                <item>eighteen<tag>out=18;</tag></item>
                <item>nineteen<tag>out=19;</tag></item>
                <item>10<tag>out=10;</tag></item>
                <item>11<tag>out=11;</tag></item>
                <item>12<tag>out=12;</tag></item>
                <item>13<tag>out=13;</tag></item>
                <item>14<tag>out=14;</tag></item>
                <item>15<tag>out=15;</tag></item>
                <item>16<tag>out=16;</tag></item>
                <item>17<tag>out=17;</tag></item>
                <item>18<tag>out=18;</tag></item>
                <item>19<tag>out=19;</tag></item>
            </one-of>
        </rule>

        <rule id="above_twenty">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>twenty<tag>out=20;</tag></item>
                <item>thirty<tag>out=30;</tag></item>
                <item>forty<tag>out=40;</tag></item>
                <item>fifty<tag>out=50;</tag></item>
                <item>sixty<tag>out=60;</tag></item>
                <item>seventy<tag>out=70;</tag></item>
                <item>eighty<tag>out=80;</tag></item>
                <item>ninety<tag>out=90;</tag></item>
                <item>20<tag>out=20;</tag></item>
                <item>30<tag>out=30;</tag></item>
                <item>40<tag>out=40;</tag></item>
                <item>50<tag>out=50;</tag></item>
                <item>60<tag>out=60;</tag></item>
                <item>70<tag>out=70;</tag></item>
                <item>80<tag>out=80;</tag></item>
                <item>90<tag>out=90;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
        </rule>

</grammar>
```

### 계좌 개설 날짜
<a name="financial-opening"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: I opened account on July Two Thousand and Eleven
                 Output: 07/11

             Scenario 2:
                 Input: I need account number opened on July Two Thousand and Eleven
                 Output: 07/11

         -->

        <rule id="main" scope="public">
            <tag>out=""</tag>
            <item repeat="1-10">
                <item repeat="1"><ruleref uri="#months"/><tag>out = out + rules.months.mon + "/";</tag></item>
                <one-of>
                    <item><ruleref uri="#thousands"/><tag>out += rules.thousands;</tag></item>
                    <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
                    <item repeat="0-1"><ruleref uri="#teens"/><tag>out += rules.teens;</tag></item>
                    <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty;</tag></item>
                </one-of>
            </item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
           <one-of>
              <item repeat="0-1">I opened account on </item>
              <item repeat="0-1">I need account number opened on </item>
           </one-of>
        </rule>

        <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>
        <rule id="months">
           <item repeat="0-1"><ruleref uri="#text"/></item>
           <tag>out.mon=""</tag>
           <one-of>
               <item>january<tag>out.mon+="01";</tag></item>
               <item>february<tag>out.mon+="02";</tag></item>
               <item>march<tag>out.mon+="03";</tag></item>
               <item>april<tag>out.mon+="04";</tag></item>
               <item>may<tag>out.mon+="05";</tag></item>
               <item>june<tag>out.mon+="06";</tag></item>
               <item>july<tag>out.mon+="07";</tag></item>
               <item>august<tag>out.mon+="08";</tag></item>
               <item>september<tag>out.mon+="09";</tag></item>
               <item>october<tag>out.mon+="10";</tag></item>
               <item>november<tag>out.mon+="11";</tag></item>
               <item>december<tag>out.mon+="12";</tag></item>
               <item>jan<tag>out.mon+="01";</tag></item>
               <item>feb<tag>out.mon+="02";</tag></item>
               <item>aug<tag>out.mon+="08";</tag></item>
               <item>sept<tag>out.mon+="09";</tag></item>
               <item>oct<tag>out.mon+="10";</tag></item>
               <item>nov<tag>out.mon+="11";</tag></item>
               <item>dec<tag>out.mon+="12";</tag></item>
           </one-of>
       </rule>

        <rule id="digits">
            <one-of>
                <item>zero<tag>out=0;</tag></item>
                <item>one<tag>out=1;</tag></item>
                <item>two<tag>out=2;</tag></item>
                <item>three<tag>out=3;</tag></item>
                <item>four<tag>out=4;</tag></item>
                <item>five<tag>out=5;</tag></item>
                <item>six<tag>out=6;</tag></item>
                <item>seven<tag>out=7;</tag></item>
                <item>eight<tag>out=8;</tag></item>
                <item>nine<tag>out=9;</tag></item>
            </one-of>
        </rule>

        <rule id="teens">
            <one-of>
                <item>ten<tag>out=10;</tag></item>
                <item>eleven<tag>out=11;</tag></item>
                <item>twelve<tag>out=12;</tag></item>
                <item>thirteen<tag>out=13;</tag></item>
                <item>fourteen<tag>out=14;</tag></item>
                <item>fifteen<tag>out=15;</tag></item>
                <item>sixteen<tag>out=16;</tag></item>
                <item>seventeen<tag>out=17;</tag></item>
                <item>eighteen<tag>out=18;</tag></item>
                <item>nineteen<tag>out=19;</tag></item>
            </one-of>
        </rule>

        <rule id="thousands">
            <item>two thousand<!--<tag>out=2000;</tag>--></item>
            <item repeat="0-1">and</item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out = rules.digits;</tag></item>
            <item repeat="0-1"><ruleref uri="#teens"/><tag>out = rules.teens;</tag></item>
            <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out = rules.above_twenty;</tag></item>
        </rule>

        <rule id="above_twenty">
            <one-of>
                <item>twenty<tag>out=20;</tag></item>
                <item>thirty<tag>out=30;</tag></item>
                <item>forty<tag>out=40;</tag></item>
                <item>fifty<tag>out=50;</tag></item>
                <item>sixty<tag>out=60;</tag></item>
                <item>seventy<tag>out=70;</tag></item>
                <item>eighty<tag>out=80;</tag></item>
                <item>ninety<tag>out=90;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
        </rule>
</grammar>
```

### 자동 결제 날짜
<a name="financial-autopay"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: I want to schedule auto pay for twenty five Dollar
                 Output: $25

             Scenario 2:
                 Input: Setup automatic payments for twenty five dollars
                 Output: $25

         -->

        <rule id="main" scope="public">
            <tag>out="$"</tag>
            <one-of>
                <item><ruleref uri="#sub_hundred"/><tag>out += rules.sub_hundred.sh;</tag></item>
                <item><ruleref uri="#subThousands"/><tag>out += rules.subThousands;</tag></item>
            </one-of>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
           <one-of>
              <item repeat="0-1">I want to schedule auto pay for</item>
              <item repeat="0-1">Setup automatic payments for twenty five dollars</item>
              <item repeat="0-1">Auto pay amount of</item>
              <item repeat="0-1">Set it up for</item>
           </one-of>
        </rule>

        <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.num = 0;</tag>
            <one-of>
                <item>0<tag>out.num+=0;</tag></item>
                <item>1<tag>out.num+=1;</tag></item>
                <item>2<tag>out.num+=2;</tag></item>
                <item>3<tag>out.num+=3;</tag></item>
                <item>4<tag>out.num+=4;</tag></item>
                <item>5<tag>out.num+=5;</tag></item>
                <item>6<tag>out.num+=6;</tag></item>
                <item>7<tag>out.num+=7;</tag></item>
                <item>8<tag>out.num+=8;</tag></item>
                <item>9<tag>out.num+=9;</tag></item>
                <item>one<tag>out.num+=1;</tag></item>
                <item>two<tag>out.num+=2;</tag></item>
                <item>three<tag>out.num+=3;</tag></item>
                <item>four<tag>out.num+=4;</tag></item>
                <item>five<tag>out.num+=5;</tag></item>
                <item>six<tag>out.num+=6;</tag></item>
                <item>seven<tag>out.num+=7;</tag></item>
                <item>eight<tag>out.num+=8;</tag></item>
                <item>nine<tag>out.num+=9;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
        </rule>

        <rule id="teens">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.teen = 0;</tag>
            <one-of>
                <item>ten<tag>out.teen+=10;</tag></item>
                <item>eleven<tag>out.teen+=11;</tag></item>
                <item>twelve<tag>out.teen+=12;</tag></item>
                <item>thirteen<tag>out.teen+=13;</tag></item>
                <item>fourteen<tag>out.teen+=14;</tag></item>
                <item>fifteen<tag>out.teen+=15;</tag></item>
                <item>sixteen<tag>out.teen+=16;</tag></item>
                <item>seventeen<tag>out.teen+=17;</tag></item>
                <item>eighteen<tag>out.teen+=18;</tag></item>
                <item>nineteen<tag>out.teen+=19;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
        </rule>

        <rule id="above_twenty">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.tens = 0;</tag>
            <one-of>
                <item>twenty<tag>out.tens+=20;</tag></item>
                <item>thirty<tag>out.tens+=30;</tag></item>
                <item>forty<tag>out.tens+=40;</tag></item>
                <item>fifty<tag>out.tens+=50;</tag></item>
                <item>sixty<tag>out.tens+=60;</tag></item>
                <item>seventy<tag>out.tens+=70;</tag></item>
                <item>eighty<tag>out.tens+=80;</tag></item>
                <item>ninety<tag>out.tens+=90;</tag></item>
                <item>hundred<tag>out.tens+=100;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out.tens += rules.digits.num;</tag></item>
        </rule>

        <rule id="currency">
            <one-of>
                <item repeat="0-1">dollars</item>
                <item repeat="0-1">Dollars</item>
                <item repeat="0-1">dollar</item>
                <item repeat="0-1">Dollar</item>
            </one-of>
        </rule>


        <rule id="sub_hundred">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.sh = 0;</tag>
            <one-of>
                <item><ruleref uri="#teens"/><tag>out.sh += rules.teens.teen;</tag></item>
                <item>
                    <ruleref uri="#above_twenty"/><tag>out.sh += rules.above_twenty.tens;</tag>
                </item>
                <item><ruleref uri="#digits"/><tag>out.sh += rules.digits.num;</tag></item>
            </one-of>
         </rule>

        <rule id="subThousands">
            <ruleref uri="#sub_hundred"/><tag>out = (100 * rules.sub_hundred.sh);</tag>
            hundred
            <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty.tens;</tag></item>
            <item repeat="0-1"><ruleref uri="#teens"/><tag>out += rules.teens.teen;</tag></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits.num;</tag></item>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
        </rule>
</grammar>
```

### 신용 카드 유효 기간
<a name="financial-ccnex"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="dateCardExpiration"
         mode="voice"
         tag-format="semantics/1.0">

        <rule id="dateCardExpiration" scope="public">
            <tag>out=""</tag>
            <item repeat="1"><ruleref uri="#months"/><tag>out = out + rules.months;</tag></item>
            <item repeat="1"><ruleref uri="#year"/><tag>out += " " + rules.year.yr;</tag></item>
        </rule>

        <!-- Test Cases

        Grammar will support the following inputs:

            Scenario 1:
                Input: My card expiration date is july eleven
                Output: 07 2011

            Scenario 2:
                Input: My card expiration date is may twenty six
                Output: 05 2026

        -->

        <rule id="text">
           <item repeat="0-1"><ruleref uri="#hesitation"/></item>
           <one-of>
              <item repeat="0-1">My card expiration date is </item>
              <item repeat="0-1">Expiration date is </item>
           </one-of>
        </rule>

        <rule id="hesitation">
          <one-of>
             <item>Hmm</item>
             <item>Mmm</item>
             <item>My</item>
          </one-of>
        </rule>

        <rule id="months">
           <item repeat="0-1"><ruleref uri="#text"/></item>
           <one-of>
               <item>january<tag>out="01";</tag></item>
               <item>february<tag>out="02";</tag></item>
               <item>march<tag>out="03";</tag></item>
               <item>april<tag>out="04";</tag></item>
               <item>may<tag>out="05";</tag></item>
               <item>june<tag>out="06";</tag></item>
               <item>july<tag>out="07";</tag></item>
               <item>august<tag>out="08";</tag></item>
               <item>september<tag>out="09";</tag></item>
               <item>october<tag>out="10";</tag></item>
               <item>november<tag>out="11";</tag></item>
               <item>december<tag>out="12";</tag></item>
               <item>jan<tag>out="01";</tag></item>
               <item>feb<tag>out="02";</tag></item>
               <item>aug<tag>out="08";</tag></item>
               <item>sept<tag>out="09";</tag></item>
               <item>oct<tag>out="10";</tag></item>
               <item>nov<tag>out="11";</tag></item>
               <item>dec<tag>out="12";</tag></item>
               <item>1<tag>out="01";</tag></item>
               <item>2<tag>out="02";</tag></item>
               <item>3<tag>out="03";</tag></item>
               <item>4<tag>out="04";</tag></item>
               <item>5<tag>out="05";</tag></item>
               <item>6<tag>out="06";</tag></item>
               <item>7<tag>out="07";</tag></item>
               <item>8<tag>out="08";</tag></item>
               <item>9<tag>out="09";</tag></item>
               <item>ten<tag>out="10";</tag></item>
               <item>eleven<tag>out="11";</tag></item>
               <item>twelve<tag>out="12";</tag></item>
           </one-of>
       </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>0<tag>out=0;</tag></item>
                <item>1<tag>out=1;</tag></item>
                <item>2<tag>out=2;</tag></item>
                <item>3<tag>out=3;</tag></item>
                <item>4<tag>out=4;</tag></item>
                <item>5<tag>out=5;</tag></item>
                <item>6<tag>out=6;</tag></item>
                <item>7<tag>out=7;</tag></item>
                <item>8<tag>out=8;</tag></item>
                <item>9<tag>out=9;</tag></item>
                <item>one<tag>out=1;</tag></item>
                <item>two<tag>out=2;</tag></item>
                <item>three<tag>out=3;</tag></item>
                <item>four<tag>out=4;</tag></item>
                <item>five<tag>out=5;</tag></item>
                <item>six<tag>out=6;</tag></item>
                <item>seven<tag>out=7;</tag></item>
                <item>eight<tag>out=8;</tag></item>
                <item>nine<tag>out=9;</tag></item>
            </one-of>
        </rule>

        <rule id="year">
          <tag>out.yr="20"</tag>
          <one-of>
              <item><ruleref uri="#teens"/><tag>out.yr += rules.teens;</tag></item>
              <item><ruleref uri="#above_twenty"/><tag>out.yr += rules.above_twenty;</tag></item>
          </one-of>
        </rule>

        <rule id="teens">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>ten<tag>out=10;</tag></item>
                <item>eleven<tag>out=11;</tag></item>
                <item>twelve<tag>out=12;</tag></item>
                <item>thirteen<tag>out=13;</tag></item>
                <item>fourteen<tag>out=14;</tag></item>
                <item>fifteen<tag>out=15;</tag></item>
                <item>sixteen<tag>out=16;</tag></item>
                <item>seventeen<tag>out=17;</tag></item>
                <item>eighteen<tag>out=18;</tag></item>
                <item>nineteen<tag>out=19;</tag></item>
                <item>10<tag>out=10;</tag></item>
                <item>11<tag>out=11;</tag></item>
                <item>12<tag>out=12;</tag></item>
                <item>13<tag>out=13;</tag></item>
                <item>14<tag>out=14;</tag></item>
                <item>15<tag>out=15;</tag></item>
                <item>16<tag>out=16;</tag></item>
                <item>17<tag>out=17;</tag></item>
                <item>18<tag>out=18;</tag></item>
                <item>19<tag>out=19;</tag></item>
            </one-of>
        </rule>

        <rule id="above_twenty">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>twenty<tag>out=20;</tag></item>
                <item>thirty<tag>out=30;</tag></item>
                <item>forty<tag>out=40;</tag></item>
                <item>fifty<tag>out=50;</tag></item>
                <item>sixty<tag>out=60;</tag></item>
                <item>seventy<tag>out=70;</tag></item>
                <item>eighty<tag>out=80;</tag></item>
                <item>ninety<tag>out=90;</tag></item>
                <item>20<tag>out=20;</tag></item>
                <item>30<tag>out=30;</tag></item>
                <item>40<tag>out=40;</tag></item>
                <item>50<tag>out=50;</tag></item>
                <item>60<tag>out=60;</tag></item>
                <item>70<tag>out=70;</tag></item>
                <item>80<tag>out=80;</tag></item>
                <item>90<tag>out=90;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
        </rule>
</grammar>
```

### 명세서 날짜
<a name="financial-statement"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: Show me statements from July Five Two Thousand and Eleven
                 Output: 07/5/11

             Scenario 2:
                 Input: Show me statements from July Sixteen Two Thousand and Eleven
                 Output: 07/16/11

             Scenario 3:
                 Input: Show me statements from July Thirty Two Thousand and Eleven
                 Output: 07/30/11
         -->

         <rule id="main" scope="public">
             <tag>out=""</tag>
             <item>
                 <item repeat="1"><ruleref uri="#months"/><tag>out = out + rules.months.mon + "/";</tag></item>
                 <one-of>
                   <item><ruleref uri="#digits"/><tag>out += rules.digits + "/";</tag></item>
                   <item><ruleref uri="#teens"/><tag>out += rules.teens+ "/";</tag></item>
                   <item><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty+ "/";</tag></item>
                 </one-of>
                 <one-of>
                     <item><ruleref uri="#thousands"/><tag>out += rules.thousands;</tag></item>
                     <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
                     <item repeat="0-1"><ruleref uri="#teens"/><tag>out += rules.teens;</tag></item>
                     <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty;</tag></item>
                 </one-of>
             </item>
         </rule>

         <rule id="text">
           <item repeat="0-1"><ruleref uri="#hesitation"/></item>
            <one-of>
               <item repeat="0-1">I want to see bank statements from </item>
               <item repeat="0-1">Show me statements from</item>
            </one-of>
         </rule>

         <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

         <rule id="months">
            <tag>out.mon=""</tag>
	        <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
              <item>january<tag>out.mon+="01";</tag></item>
              <item>february<tag>out.mon+="02";</tag></item>
              <item>march<tag>out.mon+="03";</tag></item>
              <item>april<tag>out.mon+="04";</tag></item>
              <item>may<tag>out.mon+="05";</tag></item>
              <item>june<tag>out.mon+="06";</tag></item>
              <item>july<tag>out.mon+="07";</tag></item>
              <item>august<tag>out.mon+="08";</tag></item>
              <item>september<tag>out.mon+="09";</tag></item>
              <item>october<tag>out.mon+="10";</tag></item>
              <item>november<tag>out.mon+="11";</tag></item>
              <item>december<tag>out.mon+="12";</tag></item>
              <item>jan<tag>out.mon+="01";</tag></item>
              <item>feb<tag>out.mon+="02";</tag></item>
              <item>aug<tag>out.mon+="08";</tag></item>
              <item>sept<tag>out.mon+="09";</tag></item>
              <item>oct<tag>out.mon+="10";</tag></item>
              <item>nov<tag>out.mon+="11";</tag></item>
              <item>dec<tag>out.mon+="12";</tag></item>
            </one-of>
        </rule>

         <rule id="digits">
             <one-of>
                 <item>zero<tag>out=0;</tag></item>
                 <item>one<tag>out=1;</tag></item>
                 <item>two<tag>out=2;</tag></item>
                 <item>three<tag>out=3;</tag></item>
                 <item>four<tag>out=4;</tag></item>
                 <item>five<tag>out=5;</tag></item>
                 <item>six<tag>out=6;</tag></item>
                 <item>seven<tag>out=7;</tag></item>
                 <item>eight<tag>out=8;</tag></item>
                 <item>nine<tag>out=9;</tag></item>
             </one-of>
         </rule>

         <rule id="teens">
             <one-of>
                 <item>ten<tag>out=10;</tag></item>
                 <item>eleven<tag>out=11;</tag></item>
                 <item>twelve<tag>out=12;</tag></item>
                 <item>thirteen<tag>out=13;</tag></item>
                 <item>fourteen<tag>out=14;</tag></item>
                 <item>fifteen<tag>out=15;</tag></item>
                 <item>sixteen<tag>out=16;</tag></item>
                 <item>seventeen<tag>out=17;</tag></item>
                 <item>eighteen<tag>out=18;</tag></item>
                 <item>nineteen<tag>out=19;</tag></item>
             </one-of>
         </rule>

         <rule id="thousands">
             <item>two thousand</item>
             <item repeat="0-1">and</item>
             <item repeat="0-1"><ruleref uri="#digits"/><tag>out = rules.digits;</tag></item>
             <item repeat="0-1"><ruleref uri="#teens"/><tag>out = rules.teens;</tag></item>
             <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out = rules.above_twenty;</tag></item>
         </rule>

         <rule id="above_twenty">
             <one-of>
                 <item>twenty<tag>out=20;</tag></item>
                 <item>thirty<tag>out=30;</tag></item>
             </one-of>
             <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
         </rule>
 </grammar>
```

### 거래 날짜
<a name="financial-transaction"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: My last incorrect transaction date is july twenty three
                 Output: 07/23

             Scenario 2:
                 Input: My last incorrect transaction date is july fifteen
                 Output: 07/15

         -->

        <rule id="main" scope="public">
            <tag>out=""</tag>
            <item repeat="1-10">
                <item><ruleref uri="#months"/><tag>out= rules.months.mon + "/";</tag></item>
                <one-of>
                    <item><ruleref uri="#digits"/><tag>out+= rules.digits;</tag></item>
                    <item><ruleref uri="#teens"/><tag>out+= rules.teens;</tag></item>
                    <item><ruleref uri="#above_twenty"/><tag>out+= rules.above_twenty;</tag></item>
                </one-of>
            </item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
           <one-of>
              <item repeat="0-1">My last incorrect transaction date is</item>
              <item repeat="0-1">It is</item>
           </one-of>
        </rule>
        <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

        <rule id="months">
           <item repeat="0-1"><ruleref uri="#text"/></item>
           <tag>out.mon=""</tag>
           <one-of>
               <item>january<tag>out.mon+="01";</tag></item>
               <item>february<tag>out.mon+="02";</tag></item>
               <item>march<tag>out.mon+="03";</tag></item>
               <item>april<tag>out.mon+="04";</tag></item>
               <item>may<tag>out.mon+="05";</tag></item>
               <item>june<tag>out.mon+="06";</tag></item>
               <item>july<tag>out.mon+="07";</tag></item>
               <item>august<tag>out.mon+="08";</tag></item>
               <item>september<tag>out.mon+="09";</tag></item>
               <item>october<tag>out.mon+="10";</tag></item>
               <item>november<tag>out.mon+="11";</tag></item>
               <item>december<tag>out.mon+="12";</tag></item>
               <item>jan<tag>out.mon+="01";</tag></item>
               <item>feb<tag>out.mon+="02";</tag></item>
               <item>aug<tag>out.mon+="08";</tag></item>
               <item>sept<tag>out.mon+="09";</tag></item>
               <item>oct<tag>out.mon+="10";</tag></item>
               <item>nov<tag>out.mon+="11";</tag></item>
               <item>dec<tag>out.mon+="12";</tag></item>
           </one-of>
        </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>0<tag>out=0;</tag></item>
                <item>1<tag>out=1;</tag></item>
                <item>2<tag>out=2;</tag></item>
                <item>3<tag>out=3;</tag></item>
                <item>4<tag>out=4;</tag></item>
                <item>5<tag>out=5;</tag></item>
                <item>6<tag>out=6;</tag></item>
                <item>7<tag>out=7;</tag></item>
                <item>8<tag>out=8;</tag></item>
                <item>9<tag>out=9;</tag></item>
                <item>first<tag>out=01;</tag></item>
                <item>second<tag>out=02;</tag></item>
                <item>third<tag>out=03;</tag></item>
                <item>fourth<tag>out=04;</tag></item>
                <item>fifth<tag>out=05;</tag></item>
                <item>sixth<tag>out=06;</tag></item>
                <item>seventh<tag>out=07;</tag></item>
                <item>eighth<tag>out=08;</tag></item>
                <item>ninth<tag>out=09;</tag></item>
                <item>one<tag>out=1;</tag></item>
                <item>two<tag>out=2;</tag></item>
                <item>three<tag>out=3;</tag></item>
                <item>four<tag>out=4;</tag></item>
                <item>five<tag>out=5;</tag></item>
                <item>six<tag>out=6;</tag></item>
                <item>seven<tag>out=7;</tag></item>
                <item>eight<tag>out=8;</tag></item>
                <item>nine<tag>out=9;</tag></item>
            </one-of>
        </rule>

        <rule id="teens">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>ten<tag>out=10;</tag></item>
                <item>tenth<tag>out=10;</tag></item>
                <item>eleven<tag>out=11;</tag></item>
                <item>twelve<tag>out=12;</tag></item>
                <item>thirteen<tag>out=13;</tag></item>
                <item>fourteen<tag>out=14;</tag></item>
                <item>fifteen<tag>out=15;</tag></item>
                <item>sixteen<tag>out=16;</tag></item>
                <item>seventeen<tag>out=17;</tag></item>
                <item>eighteen<tag>out=18;</tag></item>
                <item>nineteen<tag>out=19;</tag></item>
                <item>tenth<tag>out=10;</tag></item>
                <item>eleventh<tag>out=11;</tag></item>
                <item>twelveth<tag>out=12;</tag></item>
                <item>thirteenth<tag>out=13;</tag></item>
                <item>fourteenth<tag>out=14;</tag></item>
                <item>fifteenth<tag>out=15;</tag></item>
                <item>sixteenth<tag>out=16;</tag></item>
                <item>seventeenth<tag>out=17;</tag></item>
                <item>eighteenth<tag>out=18;</tag></item>
                <item>nineteenth<tag>out=19;</tag></item>
            </one-of>
        </rule>

        <rule id="above_twenty">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>twenty<tag>out=20;</tag></item>
                <item>thirty<tag>out=30;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
        </rule>
</grammar>
```

### 이체 금액
<a name="financial-transfer"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: I want to transfer twenty five Dollar
                 Output: $25

             Scenario 2:
                 Input: transfer twenty five dollars
                 Output: $25

         -->

        <rule id="main" scope="public">
            <tag>out="$"</tag>
            <one-of>
                <item><ruleref uri="#sub_hundred"/><tag>out += rules.sub_hundred.sh;</tag></item>
                <item><ruleref uri="#subThousands"/><tag>out += rules.subThousands;</tag></item>
            </one-of>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
           <one-of>
              <item repeat="0-1">I want to transfer</item>
              <item repeat="0-1">transfer</item>
              <item repeat="0-1">make a transfer for</item>
           </one-of>
        </rule>

        <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.num = 0;</tag>
            <one-of>
                <item>0<tag>out.num+=0;</tag></item>
                <item>1<tag>out.num+=1;</tag></item>
                <item>2<tag>out.num+=2;</tag></item>
                <item>3<tag>out.num+=3;</tag></item>
                <item>4<tag>out.num+=4;</tag></item>
                <item>5<tag>out.num+=5;</tag></item>
                <item>6<tag>out.num+=6;</tag></item>
                <item>7<tag>out.num+=7;</tag></item>
                <item>8<tag>out.num+=8;</tag></item>
                <item>9<tag>out.num+=9;</tag></item>
                <item>one<tag>out.num+=1;</tag></item>
                <item>two<tag>out.num+=2;</tag></item>
                <item>three<tag>out.num+=3;</tag></item>
                <item>four<tag>out.num+=4;</tag></item>
                <item>five<tag>out.num+=5;</tag></item>
                <item>six<tag>out.num+=6;</tag></item>
                <item>seven<tag>out.num+=7;</tag></item>
                <item>eight<tag>out.num+=8;</tag></item>
                <item>nine<tag>out.num+=9;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
        </rule>

        <rule id="teens">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.teen = 0;</tag>
            <one-of>
                <item>ten<tag>out.teen+=10;</tag></item>
                <item>eleven<tag>out.teen+=11;</tag></item>
                <item>twelve<tag>out.teen+=12;</tag></item>
                <item>thirteen<tag>out.teen+=13;</tag></item>
                <item>fourteen<tag>out.teen+=14;</tag></item>
                <item>fifteen<tag>out.teen+=15;</tag></item>
                <item>sixteen<tag>out.teen+=16;</tag></item>
                <item>seventeen<tag>out.teen+=17;</tag></item>
                <item>eighteen<tag>out.teen+=18;</tag></item>
                <item>nineteen<tag>out.teen+=19;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
        </rule>

        <rule id="above_twenty">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.tens = 0;</tag>
            <one-of>
                <item>twenty<tag>out.tens+=20;</tag></item>
                <item>thirty<tag>out.tens+=30;</tag></item>
                <item>forty<tag>out.tens+=40;</tag></item>
                <item>fifty<tag>out.tens+=50;</tag></item>
                <item>sixty<tag>out.tens+=60;</tag></item>
                <item>seventy<tag>out.tens+=70;</tag></item>
                <item>eighty<tag>out.tens+=80;</tag></item>
                <item>ninety<tag>out.tens+=90;</tag></item>
                <item>hundred<tag>out.tens+=100;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out.tens += rules.digits.num;</tag></item>
        </rule>

        <rule id="currency">
            <one-of>
                <item repeat="0-1">dollars</item>
                <item repeat="0-1">Dollars</item>
                <item repeat="0-1">dollar</item>
                <item repeat="0-1">Dollar</item>
            </one-of>
        </rule>


        <rule id="sub_hundred">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.sh = 0;</tag>
            <one-of>
                <item><ruleref uri="#teens"/><tag>out.sh += rules.teens.teen;</tag></item>
                <item>
                    <ruleref uri="#above_twenty"/><tag>out.sh += rules.above_twenty.tens;</tag>
                </item>
                <item><ruleref uri="#digits"/><tag>out.sh += rules.digits.num;</tag></item>
            </one-of>
         </rule>

        <rule id="subThousands">
            <ruleref uri="#sub_hundred"/><tag>out = (100 * rules.sub_hundred.sh);</tag>
            hundred
            <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty.tens;</tag></item>
            <item repeat="0-1"><ruleref uri="#teens"/><tag>out += rules.teens.teen;</tag></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits.num;</tag></item>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
        </rule>
</grammar>
```

### 사회 보장 번호
<a name="generic-ssn"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <rule id="main" scope="public">
             <tag>out=""</tag>
             <ruleref uri="#digits"/><tag>out += rules.digits.numbers;</tag>
         </rule>

         <rule id="digits">
             <tag>out.numbers=""</tag>
             <item repeat="1-12">
                 <one-of>
                     <item>0<tag>out.numbers+=0;</tag></item>
                     <item>1<tag>out.numbers+=1;</tag></item>
                     <item>2<tag>out.numbers+=2;</tag></item>
                     <item>3<tag>out.numbers+=3;</tag></item>
                     <item>4<tag>out.numbers+=4;</tag></item>
                     <item>5<tag>out.numbers+=5;</tag></item>
                     <item>6<tag>out.numbers+=6;</tag></item>
                     <item>7<tag>out.numbers+=7;</tag></item>
                     <item>8<tag>out.numbers+=8;</tag></item>
                     <item>9<tag>out.numbers+=9;</tag></item>
                     <item>zero<tag>out.numbers+=0;</tag></item>
                     <item>one<tag>out.numbers+=1;</tag></item>
                     <item>two<tag>out.numbers+=2;</tag></item>
                     <item>three<tag>out.numbers+=3;</tag></item>
                     <item>four<tag>out.numbers+=4;</tag></item>
                     <item>five<tag>out.numbers+=5;</tag></item>
                     <item>six<tag>out.numbers+=6;</tag></item>
                     <item>seven<tag>out.numbers+=7;</tag></item>
                     <item>eight<tag>out.numbers+=8;</tag></item>
                     <item>nine<tag>out.numbers+=9;</tag></item>
                     <item>dash</item>
                 </one-of>
             </item>
         </rule>
</grammar>
```

## 보험용 문법([다운로드](samples/insurance-grammars.zip))
<a name="insurance-grammers"></a>

보험 도메인에는 청구 및 증권 번호, 운전면허증 번호 및 번호판 번호, 만료일, 시작일 및 갱신일, 보험금 청구 및 보험 금액 등의 문법이 지원됩니다.

### 청구 ID
<a name="insurance-claim-id"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="digits"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: My claim number is One Five Four Two
                 Output: 1542

             Scenario 2:
                 Input: Claim number One Five Four Four
                 Output: 1544

         -->

        <rule id="digits">
            <tag>out=""</tag>
            <item><ruleref uri="#singleDigit"/><tag>out += rules.singleDigit.digit;</tag></item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
            <one-of>
                <item repeat="0-1">My claim number is</item>
                <item repeat="0-1">Claim number</item>
                <item repeat="0-1">This is for claim</item>
            </one-of>
        </rule>

        <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

        <rule id="singleDigit">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.digit=""</tag>
            <item repeat="1-10">
                <one-of>
                    <item>0<tag>out.digit+=0;</tag></item>
                    <item>zero<tag>out.digit+=0;</tag></item>
                    <item>1<tag>out.digit+=1;</tag></item>
                    <item>one<tag>out.digit+=1;</tag></item>
                    <item>2<tag>out.digit+=2;</tag></item>
                    <item>two<tag>out.digit+=2;</tag></item>
                    <item>3<tag>out.digit+=3;</tag></item>
                    <item>three<tag>out.digit+=3;</tag></item>
                    <item>4<tag>out.digit+=4;</tag></item>
                    <item>four<tag>out.digit+=4;</tag></item>
                    <item>5<tag>out.digit+=5;</tag></item>
                    <item>five<tag>out.digit+=5;</tag></item>
                    <item>6<tag>out.digit+=6;</tag></item>
                    <item>six<tag>out.digit+=5;</tag></item>
                    <item>7<tag>out.digit+=7;</tag></item>
                    <item>seven<tag>out.digit+=7;</tag></item>
                    <item>8<tag>out.digit+=8;</tag></item>
                    <item>eight<tag>out.digit+=8;</tag></item>
                    <item>9<tag>out.digit+=9;</tag></item>
                    <item>nine<tag>out.digit+=9;</tag></item>
                </one-of>
            </item>
        </rule>
</grammar>
```

### 정책 ID
<a name="insurance-policy-id"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">


        <!-- Test Cases

        Grammar will support the following inputs:

            Scenario 1:
                Input: My policy number is A B C 1 2 3 4
                Output: ABC1234

            Scenario 2:
                Input: This is the policy number 1 2 3 4 A B C
                Output: 1234ABC

            Scenario 3:
                Input: Hmm My policy number is 1 2 3 4 A B C 1
                Output: 123ABC1
        -->

        <rule id="main" scope="public">
            <tag>out=""</tag>
            <item><ruleref uri="#alphanumeric"/><tag>out += rules.alphanumeric.alphanum;</tag></item>
            <item repeat="0-1"><ruleref uri="#alphabets"/><tag>out += rules.alphabets.letters;</tag></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits.numbers</tag></item>
            <item repeat="0-1"><ruleref uri="#thanks"/></item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
            <one-of>
                <item repeat="0-1">My policy number is</item>
                <item repeat="0-1">This is the policy number</item>
                <item repeat="0-1">Policy number</item>
                <item repeat="0-1">Yes, It is</item>
                <item repeat="0-1">Yes It is</item>
                <item repeat="0-1">Yes It's</item>
                <item repeat="0-1">My policy Id is</item>
                <item repeat="0-1">This is the policy Id</item>
                <item repeat="0-1">Policy Id</item>
            </one-of>
        </rule>

        <rule id="hesitation">
          <one-of>
             <item>Hmm</item>
             <item>Mmm</item>
             <item>My</item>
          </one-of>
        </rule>

        <rule id="thanks">
            <one-of>
               <item>Thanks</item>
               <item>I think</item>
            </one-of>
          </rule>

        <rule id="alphanumeric" scope="public">
            <tag>out.alphanum=""</tag>
            <item><ruleref uri="#alphabets"/><tag>out.alphanum += rules.alphabets.letters;</tag></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out.alphanum += rules.digits.numbers</tag></item>
        </rule>

        <rule id="alphabets">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.letters=""</tag>
            <tag>out.firstOccurence=""</tag>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out.firstOccurence += rules.digits.numbers; out.letters += out.firstOccurence;</tag></item>
            <item repeat="1-">
                <one-of>
                    <item>A<tag>out.letters+='A';</tag></item>
                    <item>B<tag>out.letters+='B';</tag></item>
                    <item>C<tag>out.letters+='C';</tag></item>
                    <item>D<tag>out.letters+='D';</tag></item>
                    <item>E<tag>out.letters+='E';</tag></item>
                    <item>F<tag>out.letters+='F';</tag></item>
                    <item>G<tag>out.letters+='G';</tag></item>
                    <item>H<tag>out.letters+='H';</tag></item>
                    <item>I<tag>out.letters+='I';</tag></item>
                    <item>J<tag>out.letters+='J';</tag></item>
                    <item>K<tag>out.letters+='K';</tag></item>
                    <item>L<tag>out.letters+='L';</tag></item>
                    <item>M<tag>out.letters+='M';</tag></item>
                    <item>N<tag>out.letters+='N';</tag></item>
                    <item>O<tag>out.letters+='O';</tag></item>
                    <item>P<tag>out.letters+='P';</tag></item>
                    <item>Q<tag>out.letters+='Q';</tag></item>
                    <item>R<tag>out.letters+='R';</tag></item>
                    <item>S<tag>out.letters+='S';</tag></item>
                    <item>T<tag>out.letters+='T';</tag></item>
                    <item>U<tag>out.letters+='U';</tag></item>
                    <item>V<tag>out.letters+='V';</tag></item>
                    <item>W<tag>out.letters+='W';</tag></item>
                    <item>X<tag>out.letters+='X';</tag></item>
                    <item>Y<tag>out.letters+='Y';</tag></item>
                    <item>Z<tag>out.letters+='Z';</tag></item>
                </one-of>
            </item>
        </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.numbers=""</tag>
            <item repeat="1-10">
                <one-of>
                    <item>0<tag>out.numbers+=0;</tag></item>
                    <item>1<tag>out.numbers+=1;</tag></item>
                    <item>2<tag>out.numbers+=2;</tag></item>
                    <item>3<tag>out.numbers+=3;</tag></item>
                    <item>4<tag>out.numbers+=4;</tag></item>
                    <item>5<tag>out.numbers+=5;</tag></item>
                    <item>6<tag>out.numbers+=6;</tag></item>
                    <item>7<tag>out.numbers+=7;</tag></item>
                    <item>8<tag>out.numbers+=8;</tag></item>
                    <item>9<tag>out.numbers+=9;</tag></item>
                </one-of>
            </item>
        </rule>
</grammar>
```

### 운전 면허증 번호
<a name="insurance-dl"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="digits"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: My drivers license number is One Five Four Two
                 Output: 1542

             Scenario 2:
                 Input: driver license number One Five Four Four
                 Output: 1544

         -->

        <rule id="digits">
            <tag>out=""</tag>
            <item><ruleref uri="#singleDigit"/><tag>out += rules.singleDigit.digit;</tag></item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
            <one-of>
                <item repeat="0-1">My drivers license number is</item>
                <item repeat="0-1">My drivers license id is</item>
                <item repeat="0-1">Driver license number</item>
            </one-of>
        </rule>

        <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

        <rule id="singleDigit">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.digit=""</tag>
            <item repeat="1-10">
                <one-of>
                    <item>0<tag>out.digit+=0;</tag></item>
                    <item>zero<tag>out.digit+=0;</tag></item>
                    <item>1<tag>out.digit+=1;</tag></item>
                    <item>one<tag>out.digit+=1;</tag></item>
                    <item>2<tag>out.digit+=2;</tag></item>
                    <item>two<tag>out.digit+=2;</tag></item>
                    <item>3<tag>out.digit+=3;</tag></item>
                    <item>three<tag>out.digit+=3;</tag></item>
                    <item>4<tag>out.digit+=4;</tag></item>
                    <item>four<tag>out.digit+=4;</tag></item>
                    <item>5<tag>out.digit+=5;</tag></item>
                    <item>five<tag>out.digit+=5;</tag></item>
                    <item>6<tag>out.digit+=6;</tag></item>
                    <item>six<tag>out.digit+=5;</tag></item>
                    <item>7<tag>out.digit+=7;</tag></item>
                    <item>seven<tag>out.digit+=7;</tag></item>
                    <item>8<tag>out.digit+=8;</tag></item>
                    <item>eight<tag>out.digit+=8;</tag></item>
                    <item>9<tag>out.digit+=9;</tag></item>
                    <item>nine<tag>out.digit+=9;</tag></item>
                </one-of>
            </item>
        </rule>
</grammar>
```

### 번호판 번호
<a name="insurance-license-plate"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">


        <!-- Test Cases

        Grammar will support the following inputs:

            Scenario 1:
                Input: my license plate is A B C D 1 2
                Output: ABCD12

            Scenario 2:
                Input: license plate number A B C 1 2 3 4
                Output: ABC1234

            Scenario 3:
                Input: my plates say A F G K 9 8 7 6 Thanks 
                Output: AFGK9876
        -->

        <rule id="main" scope="public">
            <tag>out.licenseNum=""</tag>
            <item><ruleref uri="#alphabets"/><tag>out.licenseNum += rules.alphabets.letters;</tag></item>
            <item repeat="0-1"><ruleref uri="#thanks"/></item>
        </rule>
	
        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
            <one-of>
                <item repeat="0-1">my license plate is</item>
                <item repeat="0-1">license plate number</item>
                <item repeat="0-1">my plates say</item>
            </one-of>
        </rule>

        <rule id="hesitation">
          <one-of>
             <item>Hmm</item>
             <item>Mmm</item>
             <item>My</item>
          </one-of>
        </rule>

        <rule id="thanks">
            <one-of>
               <item>Thanks</item>
               <item>I think</item>
            </one-of>
          </rule>

        <rule id="alphabets">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.letters=""</tag>
            <tag>out.firstOccurence=""</tag>
            <item repeat="3-4">
                <one-of>
                    <item>A<tag>out.letters+='A';</tag></item>
                    <item>B<tag>out.letters+='B';</tag></item>
                    <item>C<tag>out.letters+='C';</tag></item>
                    <item>D<tag>out.letters+='D';</tag></item>
                    <item>E<tag>out.letters+='E';</tag></item>
                    <item>F<tag>out.letters+='F';</tag></item>
                    <item>G<tag>out.letters+='G';</tag></item>
                    <item>H<tag>out.letters+='H';</tag></item>
                    <item>I<tag>out.letters+='I';</tag></item>
                    <item>J<tag>out.letters+='J';</tag></item>
                    <item>K<tag>out.letters+='K';</tag></item>
                    <item>L<tag>out.letters+='L';</tag></item>
                    <item>M<tag>out.letters+='M';</tag></item>
                    <item>N<tag>out.letters+='N';</tag></item>
                    <item>O<tag>out.letters+='O';</tag></item>
                    <item>P<tag>out.letters+='P';</tag></item>
                    <item>Q<tag>out.letters+='Q';</tag></item>
                    <item>R<tag>out.letters+='R';</tag></item>
                    <item>S<tag>out.letters+='S';</tag></item>
                    <item>T<tag>out.letters+='T';</tag></item>
                    <item>U<tag>out.letters+='U';</tag></item>
                    <item>V<tag>out.letters+='V';</tag></item>
                    <item>W<tag>out.letters+='W';</tag></item>
                    <item>X<tag>out.letters+='X';</tag></item>
                    <item>Y<tag>out.letters+='Y';</tag></item>
                    <item>Z<tag>out.letters+='Z';</tag></item>
                </one-of>
            </item>
	    <item repeat="0-1"><ruleref uri="#digits"/><tag>out.firstOccurence += rules.digits.numbers; out.letters += out.firstOccurence;</tag></item>
        </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.numbers=""</tag>
            <item repeat="2-4">
                <one-of>
                    <item>0<tag>out.numbers+=0;</tag></item>
                    <item>1<tag>out.numbers+=1;</tag></item>
                    <item>2<tag>out.numbers+=2;</tag></item>
                    <item>3<tag>out.numbers+=3;</tag></item>
                    <item>4<tag>out.numbers+=4;</tag></item>
                    <item>5<tag>out.numbers+=5;</tag></item>
                    <item>6<tag>out.numbers+=6;</tag></item>
                    <item>7<tag>out.numbers+=7;</tag></item>
                    <item>8<tag>out.numbers+=8;</tag></item>
                    <item>9<tag>out.numbers+=9;</tag></item>
                </one-of>
            </item>
        </rule>
</grammar>
```

### 신용 카드 유효 기간
<a name="insurance-cce"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="dateCardExpiration"
         mode="voice"
         tag-format="semantics/1.0">

        <rule id="dateCardExpiration" scope="public">
            <tag>out=""</tag>
            <item repeat="1"><ruleref uri="#months"/><tag>out = out + rules.months;</tag></item>
            <item repeat="1"><ruleref uri="#year"/><tag>out += " " + rules.year.yr;</tag></item>
            <item repeat="0-1"><ruleref uri="#thanks"/></item>
        </rule>

        <!-- Test Cases

        Grammar will support the following inputs:

            Scenario 1:
                Input: My card expiration date is july eleven
                Output: 07 2011

            Scenario 2:
                Input: My card expiration date is may twenty six
                Output: 05 2026

        -->

        <rule id="text">
           <item repeat="0-1"><ruleref uri="#hesitation"/></item>
           <one-of>
              <item repeat="0-1">My card expiration date is </item>
           </one-of>
        </rule>

        <rule id="hesitation">
          <one-of>
             <item>Hmm</item>
             <item>Mmm</item>
             <item>My</item>
          </one-of>
        </rule>

        <rule id="thanks">
            <one-of>
               <item>Thanks</item>
               <item>I think</item>
            </one-of>
          </rule>

        <rule id="months">
           <item repeat="0-1"><ruleref uri="#text"/></item>
           <one-of>
               <item>january<tag>out="01";</tag></item>
               <item>february<tag>out="02";</tag></item>
               <item>march<tag>out="03";</tag></item>
               <item>april<tag>out="04";</tag></item>
               <item>may<tag>out="05";</tag></item>
               <item>june<tag>out="06";</tag></item>
               <item>july<tag>out="07";</tag></item>
               <item>august<tag>out="08";</tag></item>
               <item>september<tag>out="09";</tag></item>
               <item>october<tag>out="10";</tag></item>
               <item>november<tag>out="11";</tag></item>
               <item>december<tag>out="12";</tag></item>
               <item>jan<tag>out="01";</tag></item>
               <item>feb<tag>out="02";</tag></item>
               <item>aug<tag>out="08";</tag></item>
               <item>sept<tag>out="09";</tag></item>
               <item>oct<tag>out="10";</tag></item>
               <item>nov<tag>out="11";</tag></item>
               <item>dec<tag>out="12";</tag></item>
               <item>1<tag>out="01";</tag></item>
               <item>2<tag>out="02";</tag></item>
               <item>3<tag>out="03";</tag></item>
               <item>4<tag>out="04";</tag></item>
               <item>5<tag>out="05";</tag></item>
               <item>6<tag>out="06";</tag></item>
               <item>7<tag>out="07";</tag></item>
               <item>8<tag>out="08";</tag></item>
               <item>9<tag>out="09";</tag></item>
               <item>ten<tag>out="10";</tag></item>
               <item>eleven<tag>out="11";</tag></item>
               <item>twelve<tag>out="12";</tag></item>
           </one-of>
       </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>0<tag>out=0;</tag></item>
                <item>1<tag>out=1;</tag></item>
                <item>2<tag>out=2;</tag></item>
                <item>3<tag>out=3;</tag></item>
                <item>4<tag>out=4;</tag></item>
                <item>5<tag>out=5;</tag></item>
                <item>6<tag>out=6;</tag></item>
                <item>7<tag>out=7;</tag></item>
                <item>8<tag>out=8;</tag></item>
                <item>9<tag>out=9;</tag></item>
                <item>one<tag>out=1;</tag></item>
                <item>two<tag>out=2;</tag></item>
                <item>three<tag>out=3;</tag></item>
                <item>four<tag>out=4;</tag></item>
                <item>five<tag>out=5;</tag></item>
                <item>six<tag>out=6;</tag></item>
                <item>seven<tag>out=7;</tag></item>
                <item>eight<tag>out=8;</tag></item>
                <item>nine<tag>out=9;</tag></item>
            </one-of>
        </rule>

        <rule id="year">
          <tag>out.yr="20"</tag>
          <one-of>
              <item><ruleref uri="#teens"/><tag>out.yr += rules.teens;</tag></item>
              <item><ruleref uri="#above_twenty"/><tag>out.yr += rules.above_twenty;</tag></item>
          </one-of>
        </rule>

        <rule id="teens">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>ten<tag>out=10;</tag></item>
                <item>eleven<tag>out=11;</tag></item>
                <item>twelve<tag>out=12;</tag></item>
                <item>thirteen<tag>out=13;</tag></item>
                <item>fourteen<tag>out=14;</tag></item>
                <item>fifteen<tag>out=15;</tag></item>
                <item>sixteen<tag>out=16;</tag></item>
                <item>seventeen<tag>out=17;</tag></item>
                <item>eighteen<tag>out=18;</tag></item>
                <item>nineteen<tag>out=19;</tag></item>
                <item>10<tag>out=10;</tag></item>
                <item>11<tag>out=11;</tag></item>
                <item>12<tag>out=12;</tag></item>
                <item>13<tag>out=13;</tag></item>
                <item>14<tag>out=14;</tag></item>
                <item>15<tag>out=15;</tag></item>
                <item>16<tag>out=16;</tag></item>
                <item>17<tag>out=17;</tag></item>
                <item>18<tag>out=18;</tag></item>
                <item>19<tag>out=19;</tag></item>
            </one-of>
        </rule>

        <rule id="above_twenty">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>twenty<tag>out=20;</tag></item>
                <item>thirty<tag>out=30;</tag></item>
                <item>forty<tag>out=40;</tag></item>
                <item>fifty<tag>out=50;</tag></item>
                <item>sixty<tag>out=60;</tag></item>
                <item>seventy<tag>out=70;</tag></item>
                <item>eighty<tag>out=80;</tag></item>
                <item>ninety<tag>out=90;</tag></item>
                <item>20<tag>out=20;</tag></item>
                <item>30<tag>out=30;</tag></item>
                <item>40<tag>out=40;</tag></item>
                <item>50<tag>out=50;</tag></item>
                <item>60<tag>out=60;</tag></item>
                <item>70<tag>out=70;</tag></item>
                <item>80<tag>out=80;</tag></item>
                <item>90<tag>out=90;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
        </rule>
</grammar>
```

### 정책 만료일, 일/월/년
<a name="insurance-policy-DMY"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: My policy expired on July Five Two Thousand and Eleven
                 Output: 07/5/11

             Scenario 2:
                 Input: My policy will expire on July Sixteen Two Thousand and Eleven
                 Output: 07/16/11

             Scenario 3:
                 Input: My policy expired on July Thirty Two Thousand and Eleven
                 Output: 07/30/11
         -->

         <rule id="main" scope="public">
             <tag>out=""</tag>
             <item>
                 <item repeat="1"><ruleref uri="#months"/><tag>out = out + rules.months.mon + "/";</tag></item>
                 <one-of>
                   <item><ruleref uri="#digits"/><tag>out += rules.digits + "/";</tag></item>
                   <item><ruleref uri="#teens"/><tag>out += rules.teens+ "/";</tag></item>
                   <item><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty+ "/";</tag></item>
                 </one-of>
                 <one-of>
                     <item><ruleref uri="#thousands"/><tag>out += rules.thousands;</tag></item>
                     <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
                     <item repeat="0-1"><ruleref uri="#teens"/><tag>out += rules.teens;</tag></item>
                     <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty;</tag></item>
                 </one-of>
             </item>
         </rule>

         <rule id="text">
           <item repeat="0-1"><ruleref uri="#hesitation"/></item>
            <one-of>
               <item repeat="0-1">My policy expired on</item>
               <item repeat="0-1">My policy will expire on</item>
            </one-of>
         </rule>

         <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

         <rule id="months">
            <tag>out.mon=""</tag>
	    <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
              <item>january<tag>out.mon+="01";</tag></item>
              <item>february<tag>out.mon+="02";</tag></item>
              <item>march<tag>out.mon+="03";</tag></item>
              <item>april<tag>out.mon+="04";</tag></item>
              <item>may<tag>out.mon+="05";</tag></item>
              <item>june<tag>out.mon+="06";</tag></item>
              <item>july<tag>out.mon+="07";</tag></item>
              <item>august<tag>out.mon+="08";</tag></item>
              <item>september<tag>out.mon+="09";</tag></item>
              <item>october<tag>out.mon+="10";</tag></item>
              <item>november<tag>out.mon+="11";</tag></item>
              <item>december<tag>out.mon+="12";</tag></item>
              <item>jan<tag>out.mon+="01";</tag></item>
              <item>feb<tag>out.mon+="02";</tag></item>
              <item>aug<tag>out.mon+="08";</tag></item>
              <item>sept<tag>out.mon+="09";</tag></item>
              <item>oct<tag>out.mon+="10";</tag></item>
              <item>nov<tag>out.mon+="11";</tag></item>
              <item>dec<tag>out.mon+="12";</tag></item>
            </one-of>
        </rule>

         <rule id="digits">
             <one-of>
                 <item>zero<tag>out=0;</tag></item>
                 <item>one<tag>out=1;</tag></item>
                 <item>two<tag>out=2;</tag></item>
                 <item>three<tag>out=3;</tag></item>
                 <item>four<tag>out=4;</tag></item>
                 <item>five<tag>out=5;</tag></item>
                 <item>six<tag>out=6;</tag></item>
                 <item>seven<tag>out=7;</tag></item>
                 <item>eight<tag>out=8;</tag></item>
                 <item>nine<tag>out=9;</tag></item>
             </one-of>
         </rule>

         <rule id="teens">
             <one-of>
                 <item>ten<tag>out=10;</tag></item>
                 <item>eleven<tag>out=11;</tag></item>
                 <item>twelve<tag>out=12;</tag></item>
                 <item>thirteen<tag>out=13;</tag></item>
                 <item>fourteen<tag>out=14;</tag></item>
                 <item>fifteen<tag>out=15;</tag></item>
                 <item>sixteen<tag>out=16;</tag></item>
                 <item>seventeen<tag>out=17;</tag></item>
                 <item>eighteen<tag>out=18;</tag></item>
                 <item>nineteen<tag>out=19;</tag></item>
             </one-of>
         </rule>

         <rule id="thousands">
             <item>two thousand</item>
             <item repeat="0-1">and</item>
             <item repeat="0-1"><ruleref uri="#digits"/><tag>out = rules.digits;</tag></item>
             <item repeat="0-1"><ruleref uri="#teens"/><tag>out = rules.teens;</tag></item>
             <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out = rules.above_twenty;</tag></item>
         </rule>

         <rule id="above_twenty">
             <one-of>
                 <item>twenty<tag>out=20;</tag></item>
                 <item>thirty<tag>out=30;</tag></item>
             </one-of>
             <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
         </rule>
 </grammar>
```

### 정책 갱신일, 월/년
<a name="insurance-renewal"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: I renewed my policy on July Two Thousand and Eleven
                 Output: 07/11

             Scenario 2:
                 Input: My policy will renew on July Two Thousand and Eleven
                 Output: 07/11

         -->

        <rule id="main" scope="public">
            <tag>out=""</tag>
            <item repeat="1-10">
                <item repeat="1"><ruleref uri="#months"/><tag>out = out + rules.months.mon + "/";</tag></item>
                <one-of>
                    <item><ruleref uri="#thousands"/><tag>out += rules.thousands;</tag></item>
                    <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
                    <item repeat="0-1"><ruleref uri="#teens"/><tag>out += rules.teens;</tag></item>
                    <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty;</tag></item>
                </one-of>
            </item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
            <one-of>
                <item repeat="0-1">My policy will renew on</item>
                <item repeat="0-1">My policy was renewed on</item>
                <item repeat="0-1">Renew policy on</item>
                <item repeat="0-1">I renewed my policy on</item>
            </one-of>
        </rule>
        
        <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

        <rule id="months">
           <item repeat="0-1"><ruleref uri="#text"/></item>
           <tag>out.mon=""</tag>
           <one-of>
               <item>january<tag>out.mon+="01";</tag></item>
               <item>february<tag>out.mon+="02";</tag></item>
               <item>march<tag>out.mon+="03";</tag></item>
               <item>april<tag>out.mon+="04";</tag></item>
               <item>may<tag>out.mon+="05";</tag></item>
               <item>june<tag>out.mon+="06";</tag></item>
               <item>july<tag>out.mon+="07";</tag></item>
               <item>august<tag>out.mon+="08";</tag></item>
               <item>september<tag>out.mon+="09";</tag></item>
               <item>october<tag>out.mon+="10";</tag></item>
               <item>november<tag>out.mon+="11";</tag></item>
               <item>december<tag>out.mon+="12";</tag></item>
               <item>jan<tag>out.mon+="01";</tag></item>
               <item>feb<tag>out.mon+="02";</tag></item>
               <item>aug<tag>out.mon+="08";</tag></item>
               <item>sept<tag>out.mon+="09";</tag></item>
               <item>oct<tag>out.mon+="10";</tag></item>
               <item>nov<tag>out.mon+="11";</tag></item>
               <item>dec<tag>out.mon+="12";</tag></item>
           </one-of>
       </rule>

        <rule id="digits">
            <one-of>
                <item>zero<tag>out=0;</tag></item>
                <item>one<tag>out=1;</tag></item>
                <item>two<tag>out=2;</tag></item>
                <item>three<tag>out=3;</tag></item>
                <item>four<tag>out=4;</tag></item>
                <item>five<tag>out=5;</tag></item>
                <item>six<tag>out=6;</tag></item>
                <item>seven<tag>out=7;</tag></item>
                <item>eight<tag>out=8;</tag></item>
                <item>nine<tag>out=9;</tag></item>
            </one-of>
        </rule>

        <rule id="teens">
            <one-of>
                <item>ten<tag>out=10;</tag></item>
                <item>eleven<tag>out=11;</tag></item>
                <item>twelve<tag>out=12;</tag></item>
                <item>thirteen<tag>out=13;</tag></item>
                <item>fourteen<tag>out=14;</tag></item>
                <item>fifteen<tag>out=15;</tag></item>
                <item>sixteen<tag>out=16;</tag></item>
                <item>seventeen<tag>out=17;</tag></item>
                <item>eighteen<tag>out=18;</tag></item>
                <item>nineteen<tag>out=19;</tag></item>
            </one-of>
        </rule>

        <rule id="thousands">
            <item>two thousand<!--<tag>out=2000;</tag>--></item>
            <item repeat="0-1">and</item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out = rules.digits;</tag></item>
            <item repeat="0-1"><ruleref uri="#teens"/><tag>out = rules.teens;</tag></item>
            <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out = rules.above_twenty;</tag></item>
        </rule>

        <rule id="above_twenty">
            <one-of>
                <item>twenty<tag>out=20;</tag></item>
                <item>thirty<tag>out=30;</tag></item>
                <item>forty<tag>out=40;</tag></item>
                <item>fifty<tag>out=50;</tag></item>
                <item>sixty<tag>out=60;</tag></item>
                <item>seventy<tag>out=70;</tag></item>
                <item>eighty<tag>out=80;</tag></item>
                <item>ninety<tag>out=90;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
        </rule>
</grammar>
```

### 정책 시작 날짜
<a name="insurance-start"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: I bought my policy on july twenty three
                 Output: 07/23

             Scenario 2:
                 Input: My policy started on july fifteen
                 Output: 07/15

         -->

        <rule id="main" scope="public">
            <tag>out=""</tag>
            <item repeat="1-10">
                <item><ruleref uri="#months"/><tag>out= rules.months.mon + "/";</tag></item>
                <one-of>
                    <item><ruleref uri="#digits"/><tag>out+= rules.digits;</tag></item>
                    <item><ruleref uri="#teens"/><tag>out+= rules.teens;</tag></item>
                    <item><ruleref uri="#above_twenty"/><tag>out+= rules.above_twenty;</tag></item>
                </one-of>
            </item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
             <one-of>
                <item repeat="0-1">I bought my policy on</item>
                <item repeat="0-1">I bought policy on</item>
                <item repeat="0-1">My policy started on</item>
             </one-of>
          </rule>

          <rule id="hesitation">
             <one-of>
                <item>Hmm</item>
                <item>Mmm</item>
                <item>My</item>
             </one-of>
           </rule>

        <rule id="months">
           <item repeat="0-1"><ruleref uri="#text"/></item>
           <tag>out.mon=""</tag>
           <one-of>
               <item>january<tag>out.mon+="01";</tag></item>
               <item>february<tag>out.mon+="02";</tag></item>
               <item>march<tag>out.mon+="03";</tag></item>
               <item>april<tag>out.mon+="04";</tag></item>
               <item>may<tag>out.mon+="05";</tag></item>
               <item>june<tag>out.mon+="06";</tag></item>
               <item>july<tag>out.mon+="07";</tag></item>
               <item>august<tag>out.mon+="08";</tag></item>
               <item>september<tag>out.mon+="09";</tag></item>
               <item>october<tag>out.mon+="10";</tag></item>
               <item>november<tag>out.mon+="11";</tag></item>
               <item>december<tag>out.mon+="12";</tag></item>
               <item>jan<tag>out.mon+="01";</tag></item>
               <item>feb<tag>out.mon+="02";</tag></item>
               <item>aug<tag>out.mon+="08";</tag></item>
               <item>sept<tag>out.mon+="09";</tag></item>
               <item>oct<tag>out.mon+="10";</tag></item>
               <item>nov<tag>out.mon+="11";</tag></item>
               <item>dec<tag>out.mon+="12";</tag></item>
           </one-of>
        </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>0<tag>out=0;</tag></item>
                <item>1<tag>out=1;</tag></item>
                <item>2<tag>out=2;</tag></item>
                <item>3<tag>out=3;</tag></item>
                <item>4<tag>out=4;</tag></item>
                <item>5<tag>out=5;</tag></item>
                <item>6<tag>out=6;</tag></item>
                <item>7<tag>out=7;</tag></item>
                <item>8<tag>out=8;</tag></item>
                <item>9<tag>out=9;</tag></item>
                <item>first<tag>out=01;</tag></item>
                <item>second<tag>out=02;</tag></item>
                <item>third<tag>out=03;</tag></item>
                <item>fourth<tag>out=04;</tag></item>
                <item>fifth<tag>out=05;</tag></item>
                <item>sixth<tag>out=06;</tag></item>
                <item>seventh<tag>out=07;</tag></item>
                <item>eighth<tag>out=08;</tag></item>
                <item>ninth<tag>out=09;</tag></item>
                <item>one<tag>out=1;</tag></item>
                <item>two<tag>out=2;</tag></item>
                <item>three<tag>out=3;</tag></item>
                <item>four<tag>out=4;</tag></item>
                <item>five<tag>out=5;</tag></item>
                <item>six<tag>out=6;</tag></item>
                <item>seven<tag>out=7;</tag></item>
                <item>eight<tag>out=8;</tag></item>
                <item>nine<tag>out=9;</tag></item>
            </one-of>
        </rule>

        <rule id="teens">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>ten<tag>out=10;</tag></item>
                <item>tenth<tag>out=10;</tag></item>
                <item>eleven<tag>out=11;</tag></item>
                <item>twelve<tag>out=12;</tag></item>
                <item>thirteen<tag>out=13;</tag></item>
                <item>fourteen<tag>out=14;</tag></item>
                <item>fifteen<tag>out=15;</tag></item>
                <item>sixteen<tag>out=16;</tag></item>
                <item>seventeen<tag>out=17;</tag></item>
                <item>eighteen<tag>out=18;</tag></item>
                <item>nineteen<tag>out=19;</tag></item>
                <item>tenth<tag>out=10;</tag></item>
                <item>eleventh<tag>out=11;</tag></item>
                <item>twelveth<tag>out=12;</tag></item>
                <item>thirteenth<tag>out=13;</tag></item>
                <item>fourteenth<tag>out=14;</tag></item>
                <item>fifteenth<tag>out=15;</tag></item>
                <item>sixteenth<tag>out=16;</tag></item>
                <item>seventeenth<tag>out=17;</tag></item>
                <item>eighteenth<tag>out=18;</tag></item>
                <item>nineteenth<tag>out=19;</tag></item>
            </one-of>
        </rule>

        <rule id="above_twenty">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>twenty<tag>out=20;</tag></item>
                <item>thirty<tag>out=30;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
        </rule>
</grammar>
```

### 청구 금액
<a name="insurance-claim-amount"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: I want to make a claim of one hundre ten dollars
                 Output: $110

             Scenario 2:
                 Input: Requesting claim of Two hundred dollars
                 Output: $200

         -->

        <rule id="main" scope="public">
            <tag>out="$"</tag>
            <one-of>
                <item><ruleref uri="#sub_hundred"/><tag>out += rules.sub_hundred.sh;</tag></item>
                <item><ruleref uri="#subThousands"/><tag>out += rules.subThousands;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#thanks"/></item>
        </rule>

        <rule id="text">
           <item repeat="0-1"><ruleref uri="#hesitation"/></item>
           <one-of>
              <item repeat="0-1">I want to place a claim for</item>
              <item repeat="0-1">I want to make a claim of</item>
              <item repeat="0-1">I assess damage of</item>
              <item repeat="0-1">Requesting claim of</item>
           </one-of>
        </rule>

        <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

          <rule id="thanks">
              <one-of>
                 <item>Thanks</item>
                 <item>I think</item>
              </one-of>
            </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.num = 0;</tag>
            <one-of>
                <item>0<tag>out.num+=0;</tag></item>
                <item>1<tag>out.num+=1;</tag></item>
                <item>2<tag>out.num+=2;</tag></item>
                <item>3<tag>out.num+=3;</tag></item>
                <item>4<tag>out.num+=4;</tag></item>
                <item>5<tag>out.num+=5;</tag></item>
                <item>6<tag>out.num+=6;</tag></item>
                <item>7<tag>out.num+=7;</tag></item>
                <item>8<tag>out.num+=8;</tag></item>
                <item>9<tag>out.num+=9;</tag></item>
                <item>one<tag>out.num+=1;</tag></item>
                <item>two<tag>out.num+=2;</tag></item>
                <item>three<tag>out.num+=3;</tag></item>
                <item>four<tag>out.num+=4;</tag></item>
                <item>five<tag>out.num+=5;</tag></item>
                <item>six<tag>out.num+=6;</tag></item>
                <item>seven<tag>out.num+=7;</tag></item>
                <item>eight<tag>out.num+=8;</tag></item>
                <item>nine<tag>out.num+=9;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
        </rule>

        <rule id="teens">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.teen = 0;</tag>
            <one-of>
                <item>ten<tag>out.teen+=10;</tag></item>
                <item>eleven<tag>out.teen+=11;</tag></item>
                <item>twelve<tag>out.teen+=12;</tag></item>
                <item>thirteen<tag>out.teen+=13;</tag></item>
                <item>fourteen<tag>out.teen+=14;</tag></item>
                <item>fifteen<tag>out.teen+=15;</tag></item>
                <item>sixteen<tag>out.teen+=16;</tag></item>
                <item>seventeen<tag>out.teen+=17;</tag></item>
                <item>eighteen<tag>out.teen+=18;</tag></item>
                <item>nineteen<tag>out.teen+=19;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
        </rule>

        <rule id="above_twenty">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.tens = 0;</tag>
            <one-of>
                <item>twenty<tag>out.tens+=20;</tag></item>
                <item>thirty<tag>out.tens+=30;</tag></item>
                <item>forty<tag>out.tens+=40;</tag></item>
                <item>fifty<tag>out.tens+=50;</tag></item>
                <item>sixty<tag>out.tens+=60;</tag></item>
                <item>seventy<tag>out.tens+=70;</tag></item>
                <item>eighty<tag>out.tens+=80;</tag></item>
                <item>ninety<tag>out.tens+=90;</tag></item>
                <item>hundred<tag>out.tens+=100;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out.tens += rules.digits.num;</tag></item>
        </rule>

        <rule id="currency">
            <one-of>
                <item repeat="0-1">dollars</item>
                <item repeat="0-1">Dollars</item>
                <item repeat="0-1">dollar</item>
                <item repeat="0-1">Dollar</item>
            </one-of>
        </rule>


        <rule id="sub_hundred">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.sh = 0;</tag>
            <one-of>
                <item><ruleref uri="#teens"/><tag>out.sh += rules.teens.teen;</tag></item>
                <item>
                    <ruleref uri="#above_twenty"/><tag>out.sh += rules.above_twenty.tens;</tag>
                </item>
                <item><ruleref uri="#digits"/><tag>out.sh += rules.digits.num;</tag></item>
            </one-of>
         </rule>

        <rule id="subThousands">
            <ruleref uri="#sub_hundred"/><tag>out = (100 * rules.sub_hundred.sh);</tag>
            hundred
            <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty.tens;</tag></item>
            <item repeat="0-1"><ruleref uri="#teens"/><tag>out += rules.teens.teen;</tag></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits.num;</tag></item>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
        </rule>
</grammar>
```

### 프리미엄 금액
<a name="insurance-premium"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Premium amounts
             Scenario 1:
                 Input: The premium for one hundre ten dollars
                 Output: $110

             Scenario 2:
                 Input: RPremium amount of Two hundred dollars
                 Output: $200

         -->

        <rule id="main" scope="public">
            <tag>out="$"</tag>
            <one-of>
                <item><ruleref uri="#sub_hundred"/><tag>out += rules.sub_hundred.sh;</tag></item>
                <item><ruleref uri="#subThousands"/><tag>out += rules.subThousands;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#thanks"/></item>
        </rule>

        <rule id="text">
           <item repeat="0-1"><ruleref uri="#hesitation"/></item>
           <one-of>
              <item repeat="0-1">A premium of</item>
              <item repeat="0-1">Premium amount of</item>
              <item repeat="0-1">The premium for</item>
              <item repeat="0-1">Insurance premium for</item>
           </one-of>
        </rule>

        <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

          <rule id="thanks">
              <one-of>
                 <item>Thanks</item>
                 <item>I think</item>
              </one-of>
            </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.num = 0;</tag>
            <one-of>
                <item>0<tag>out.num+=0;</tag></item>
                <item>1<tag>out.num+=1;</tag></item>
                <item>2<tag>out.num+=2;</tag></item>
                <item>3<tag>out.num+=3;</tag></item>
                <item>4<tag>out.num+=4;</tag></item>
                <item>5<tag>out.num+=5;</tag></item>
                <item>6<tag>out.num+=6;</tag></item>
                <item>7<tag>out.num+=7;</tag></item>
                <item>8<tag>out.num+=8;</tag></item>
                <item>9<tag>out.num+=9;</tag></item>
                <item>one<tag>out.num+=1;</tag></item>
                <item>two<tag>out.num+=2;</tag></item>
                <item>three<tag>out.num+=3;</tag></item>
                <item>four<tag>out.num+=4;</tag></item>
                <item>five<tag>out.num+=5;</tag></item>
                <item>six<tag>out.num+=6;</tag></item>
                <item>seven<tag>out.num+=7;</tag></item>
                <item>eight<tag>out.num+=8;</tag></item>
                <item>nine<tag>out.num+=9;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
        </rule>

        <rule id="teens">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.teen = 0;</tag>
            <one-of>
                <item>ten<tag>out.teen+=10;</tag></item>
                <item>eleven<tag>out.teen+=11;</tag></item>
                <item>twelve<tag>out.teen+=12;</tag></item>
                <item>thirteen<tag>out.teen+=13;</tag></item>
                <item>fourteen<tag>out.teen+=14;</tag></item>
                <item>fifteen<tag>out.teen+=15;</tag></item>
                <item>sixteen<tag>out.teen+=16;</tag></item>
                <item>seventeen<tag>out.teen+=17;</tag></item>
                <item>eighteen<tag>out.teen+=18;</tag></item>
                <item>nineteen<tag>out.teen+=19;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
        </rule>

        <rule id="above_twenty">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.tens = 0;</tag>
            <one-of>
                <item>twenty<tag>out.tens+=20;</tag></item>
                <item>thirty<tag>out.tens+=30;</tag></item>
                <item>forty<tag>out.tens+=40;</tag></item>
                <item>fifty<tag>out.tens+=50;</tag></item>
                <item>sixty<tag>out.tens+=60;</tag></item>
                <item>seventy<tag>out.tens+=70;</tag></item>
                <item>eighty<tag>out.tens+=80;</tag></item>
                <item>ninety<tag>out.tens+=90;</tag></item>
                <item>hundred<tag>out.tens+=100;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out.tens += rules.digits.num;</tag></item>
        </rule>

        <rule id="currency">
            <one-of>
                <item repeat="0-1">dollars</item>
                <item repeat="0-1">Dollars</item>
                <item repeat="0-1">dollar</item>
                <item repeat="0-1">Dollar</item>
            </one-of>
        </rule>


        <rule id="sub_hundred">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.sh = 0;</tag>
            <one-of>
                <item><ruleref uri="#teens"/><tag>out.sh += rules.teens.teen;</tag></item>
                <item>
                    <ruleref uri="#above_twenty"/><tag>out.sh += rules.above_twenty.tens;</tag>
                </item>
                <item><ruleref uri="#digits"/><tag>out.sh += rules.digits.num;</tag></item>
            </one-of>
         </rule>

        <rule id="subThousands">
            <ruleref uri="#sub_hundred"/><tag>out = (100 * rules.sub_hundred.sh);</tag>
            hundred
            <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty.tens;</tag></item>
            <item repeat="0-1"><ruleref uri="#teens"/><tag>out += rules.teens.teen;</tag></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits.num;</tag></item>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
        </rule>
</grammar>
```

### 정책 수량
<a name="insurance-policy-quantity"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: The number is one
                 Output: 1

             Scenario 2:
                 Input: I want policy for ten
                 Output: 10

         -->

        <rule id="main" scope="public">
            <tag>out=""</tag>
            <one-of>
              <item repeat="1"><ruleref uri="#digits"/><tag>out+= rules.digits;</tag></item>
              <item repeat="1"><ruleref uri="#teens"/><tag>out+= rules.teens;</tag></item>
              <item repeat="1"><ruleref uri="#above_twenty"/><tag>out+= rules.above_twenty;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#thanks"/></item>
        </rule>

        <rule id="text">
           <one-of>
              <item repeat="0-1">I want policy for</item>
              <item repeat="0-1">I want to order policy for</item>
              <item repeat="0-1">The number is</item>
           </one-of>
        </rule>

        <rule id="thanks">
            <one-of>
               <item>Thanks</item>
               <item>I think</item>
            </one-of>
          </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>0<tag>out=0;</tag></item>
                <item>1<tag>out=1;</tag></item>
                <item>2<tag>out=2;</tag></item>
                <item>3<tag>out=3;</tag></item>
                <item>4<tag>out=4;</tag></item>
                <item>5<tag>out=5;</tag></item>
                <item>6<tag>out=6;</tag></item>
                <item>7<tag>out=7;</tag></item>
                <item>8<tag>out=8;</tag></item>
                <item>9<tag>out=9;</tag></item>
                <item>one<tag>out=1;</tag></item>
                <item>two<tag>out=2;</tag></item>
                <item>three<tag>out=3;</tag></item>
                <item>four<tag>out=4;</tag></item>
                <item>five<tag>out=5;</tag></item>
                <item>six<tag>out=6;</tag></item>
                <item>seven<tag>out=7;</tag></item>
                <item>eight<tag>out=8;</tag></item>
                <item>nine<tag>out=9;</tag></item>
            </one-of>
        </rule>

        <rule id="teens">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>ten<tag>out=10;</tag></item>
                <item>eleven<tag>out=11;</tag></item>
                <item>twelve<tag>out=12;</tag></item>
                <item>thirteen<tag>out=13;</tag></item>
                <item>fourteen<tag>out=14;</tag></item>
                <item>fifteen<tag>out=15;</tag></item>
                <item>sixteen<tag>out=16;</tag></item>
                <item>seventeen<tag>out=17;</tag></item>
                <item>eighteen<tag>out=18;</tag></item>
                <item>nineteen<tag>out=19;</tag></item>
                <item>10<tag>out=10;</tag></item>
                <item>11<tag>out=11;</tag></item>
                <item>12<tag>out=12;</tag></item>
                <item>13<tag>out=13;</tag></item>
                <item>14<tag>out=14;</tag></item>
                <item>15<tag>out=15;</tag></item>
                <item>16<tag>out=16;</tag></item>
                <item>17<tag>out=17;</tag></item>
                <item>18<tag>out=18;</tag></item>
                <item>19<tag>out=19;</tag></item>
            </one-of>
        </rule>

        <rule id="above_twenty">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>twenty<tag>out=20;</tag></item>
                <item>thirty<tag>out=30;</tag></item>
                <item>forty<tag>out=40;</tag></item>
                <item>fifty<tag>out=50;</tag></item>
                <item>sixty<tag>out=60;</tag></item>
                <item>seventy<tag>out=70;</tag></item>
                <item>eighty<tag>out=80;</tag></item>
                <item>ninety<tag>out=90;</tag></item>
                <item>20<tag>out=20;</tag></item>
                <item>30<tag>out=30;</tag></item>
                <item>40<tag>out=40;</tag></item>
                <item>50<tag>out=50;</tag></item>
                <item>60<tag>out=60;</tag></item>
                <item>70<tag>out=70;</tag></item>
                <item>80<tag>out=80;</tag></item>
                <item>90<tag>out=90;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
        </rule>

</grammar>
```

## 통신용 문법([다운로드](samples/telecom-grammars.zip))
<a name="telecom-grammers"></a>

통신에서 지원되는 문법은 다음과 같습니다: 전화번호, 일련 번호, SIM 번호, 미국 우편번호, 신용 카드 만료일, 플랜 시작일, 갱신 및 만료일, 서비스 시작일, 장비 수량 및 청구 금액.

### 전화번호
<a name="telecom-phone"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="digits"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support 10-12 digits number and here are couple of examples of valid inputs:

             Scenario 1:
                 Input: Mmm My phone number is two zero one two five two six seven eight five
                 Output: 2012526785

             Scenario 2:
                 Input: My phone number is two zero one two five two six seven eight five
                 Output: 2012526785

         -->

        <rule id="digits">
            <tag>out=""</tag>
            <item><ruleref uri="#singleDigit"/><tag>out += rules.singleDigit.digit;</tag></item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
           <one-of>
              <item repeat="0-1">My phone number is</item>
              <item repeat="0-1">Phone number is</item>
              <item repeat="0-1">It is</item>
              <item repeat="0-1">Yes, it's</item>
              <item repeat="0-1">Yes, it is</item>
              <item repeat="0-1">Yes it is</item>
           </one-of>
        </rule>

        <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

        <rule id="singleDigit">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.digit=""</tag>
            <item repeat="10-12">
                <one-of>
                    <item>0<tag>out.digit+=0;</tag></item>
                    <item>zero<tag>out.digit+=0;</tag></item>
                    <item>1<tag>out.digit+=1;</tag></item>
                    <item>one<tag>out.digit+=1;</tag></item>
                    <item>2<tag>out.digit+=2;</tag></item>
                    <item>two<tag>out.digit+=2;</tag></item>
                    <item>3<tag>out.digit+=3;</tag></item>
                    <item>three<tag>out.digit+=3;</tag></item>
                    <item>4<tag>out.digit+=4;</tag></item>
                    <item>four<tag>out.digit+=4;</tag></item>
                    <item>5<tag>out.digit+=5;</tag></item>
                    <item>five<tag>out.digit+=5;</tag></item>
                    <item>6<tag>out.digit+=6;</tag></item>
                    <item>six<tag>out.digit+=5;</tag></item>
                    <item>7<tag>out.digit+=7;</tag></item>
                    <item>seven<tag>out.digit+=7;</tag></item>
                    <item>8<tag>out.digit+=8;</tag></item>
                    <item>eight<tag>out.digit+=8;</tag></item>
                    <item>9<tag>out.digit+=9;</tag></item>
                    <item>nine<tag>out.digit+=9;</tag></item>
                </one-of>
            </item>
        </rule>
</grammar>
```

### 일련 번호
<a name="telecom-serial"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="digits"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: My serial number is 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6
                 Output: 123456789123456

             Scenario 2:
                 Input: Device Serial number 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6
                 Output: 123456789123456

         -->

        <rule id="digits">
            <tag>out=""</tag>
            <item><ruleref uri="#singleDigit"/><tag>out += rules.singleDigit.digit;</tag></item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
            <one-of>
                <item repeat="0-1">My serial number is</item>
                <item repeat="0-1">Device Serial number</item>
                <item repeat="0-1">The number is</item>
                <item repeat="0-1">The IMEI number is</item>
            </one-of>
        </rule>

        <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

        <rule id="singleDigit">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.digit=""</tag>
            <item repeat="15">
                <one-of>
                    <item>0<tag>out.digit+=0;</tag></item>
                    <item>zero<tag>out.digit+=0;</tag></item>
                    <item>1<tag>out.digit+=1;</tag></item>
                    <item>one<tag>out.digit+=1;</tag></item>
                    <item>2<tag>out.digit+=2;</tag></item>
                    <item>two<tag>out.digit+=2;</tag></item>
                    <item>3<tag>out.digit+=3;</tag></item>
                    <item>three<tag>out.digit+=3;</tag></item>
                    <item>4<tag>out.digit+=4;</tag></item>
                    <item>four<tag>out.digit+=4;</tag></item>
                    <item>5<tag>out.digit+=5;</tag></item>
                    <item>five<tag>out.digit+=5;</tag></item>
                    <item>6<tag>out.digit+=6;</tag></item>
                    <item>six<tag>out.digit+=5;</tag></item>
                    <item>7<tag>out.digit+=7;</tag></item>
                    <item>seven<tag>out.digit+=7;</tag></item>
                    <item>8<tag>out.digit+=8;</tag></item>
                    <item>eight<tag>out.digit+=8;</tag></item>
                    <item>9<tag>out.digit+=9;</tag></item>
                    <item>nine<tag>out.digit+=9;</tag></item>
                </one-of>
            </item>
        </rule>
</grammar>
```

### SIM 번호
<a name="telecom-sim"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">


        <!-- Test Cases

        Grammar will support the following inputs:

            Scenario 1:
                Input: My SIM number is A B C 1 2 3 4
                Output: ABC1234

            Scenario 2:
                Input: My SIM number is 1 2 3 4 A B C
                Output: 1234ABC

            Scenario 3:
                Input: My SIM number is 1 2 3 4 A B C 1
                Output: 123ABC1
        -->

        <rule id="main" scope="public">
            <tag>out=""</tag>
            <item><ruleref uri="#alphanumeric"/><tag>out += rules.alphanumeric.alphanum;</tag></item>
            <item repeat="0-1"><ruleref uri="#alphabets"/><tag>out += rules.alphabets.letters;</tag></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits.numbers</tag></item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
            <one-of>
                <item repeat="0-1">My SIM number is</item>
                <item repeat="0-1">SIM number is</item>
            </one-of>
        </rule>

        <rule id="hesitation">
          <one-of>
             <item>Hmm</item>
             <item>Mmm</item>
             <item>My</item>
          </one-of>
        </rule>

        <rule id="alphanumeric" scope="public">
            <tag>out.alphanum=""</tag>
            <item><ruleref uri="#alphabets"/><tag>out.alphanum += rules.alphabets.letters;</tag></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out.alphanum += rules.digits.numbers</tag></item>
        </rule>

        <rule id="alphabets">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.letters=""</tag>
            <tag>out.firstOccurence=""</tag>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out.firstOccurence += rules.digits.numbers; out.letters += out.firstOccurence;</tag></item>
            <item repeat="1-">
                <one-of>
                    <item>A<tag>out.letters+='A';</tag></item>
                    <item>B<tag>out.letters+='B';</tag></item>
                    <item>C<tag>out.letters+='C';</tag></item>
                    <item>D<tag>out.letters+='D';</tag></item>
                    <item>E<tag>out.letters+='E';</tag></item>
                    <item>F<tag>out.letters+='F';</tag></item>
                    <item>G<tag>out.letters+='G';</tag></item>
                    <item>H<tag>out.letters+='H';</tag></item>
                    <item>I<tag>out.letters+='I';</tag></item>
                    <item>J<tag>out.letters+='J';</tag></item>
                    <item>K<tag>out.letters+='K';</tag></item>
                    <item>L<tag>out.letters+='L';</tag></item>
                    <item>M<tag>out.letters+='M';</tag></item>
                    <item>N<tag>out.letters+='N';</tag></item>
                    <item>O<tag>out.letters+='O';</tag></item>
                    <item>P<tag>out.letters+='P';</tag></item>
                    <item>Q<tag>out.letters+='Q';</tag></item>
                    <item>R<tag>out.letters+='R';</tag></item>
                    <item>S<tag>out.letters+='S';</tag></item>
                    <item>T<tag>out.letters+='T';</tag></item>
                    <item>U<tag>out.letters+='U';</tag></item>
                    <item>V<tag>out.letters+='V';</tag></item>
                    <item>W<tag>out.letters+='W';</tag></item>
                    <item>X<tag>out.letters+='X';</tag></item>
                    <item>Y<tag>out.letters+='Y';</tag></item>
                    <item>Z<tag>out.letters+='Z';</tag></item>
                </one-of>
            </item>
        </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.numbers=""</tag>
            <item repeat="1-10">
                <one-of>
                    <item>0<tag>out.numbers+=0;</tag></item>
                    <item>1<tag>out.numbers+=1;</tag></item>
                    <item>2<tag>out.numbers+=2;</tag></item>
                    <item>3<tag>out.numbers+=3;</tag></item>
                    <item>4<tag>out.numbers+=4;</tag></item>
                    <item>5<tag>out.numbers+=5;</tag></item>
                    <item>6<tag>out.numbers+=6;</tag></item>
                    <item>7<tag>out.numbers+=7;</tag></item>
                    <item>8<tag>out.numbers+=8;</tag></item>
                    <item>9<tag>out.numbers+=9;</tag></item>
                </one-of>
            </item>
        </rule>
</grammar>
```

### 미국 우편번호
<a name="telecom-zip"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="digits"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support 5 digits code and here are couple of examples of valid inputs:

             Scenario 1:
                 Input: Mmmm My zipcode is umm One Oh Nine Eight Seven
                 Output: 10987

             Scenario 2:
                 Input: My zipcode is One Oh Nine Eight Seven
                 Output: 10987

         -->

        <rule id="digits">
            <tag>out=""</tag>
            <item><ruleref uri="#singleDigit"/><tag>out += rules.singleDigit.digit;</tag></item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
           <one-of>
              <item repeat="0-1">My zipcode is</item>
              <item repeat="0-1">Zipcode is</item>
              <item repeat="0-1">It is</item>
           </one-of>
        </rule>

        <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

        <rule id="singleDigit">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.digit=""</tag>
            <item repeat="5">
                <one-of>
                    <item>0<tag>out.digit+=0;</tag></item>
                    <item>zero<tag>out.digit+=0;</tag></item>
                    <item>Oh<tag>out.digit+=0;</tag></item>
                    <item>1<tag>out.digit+=1;</tag></item>
                    <item>one<tag>out.digit+=1;</tag></item>
                    <item>2<tag>out.digit+=2;</tag></item>
                    <item>two<tag>out.digit+=2;</tag></item>
                    <item>3<tag>out.digit+=3;</tag></item>
                    <item>three<tag>out.digit+=3;</tag></item>
                    <item>4<tag>out.digit+=4;</tag></item>
                    <item>four<tag>out.digit+=4;</tag></item>
                    <item>5<tag>out.digit+=5;</tag></item>
                    <item>five<tag>out.digit+=5;</tag></item>
                    <item>6<tag>out.digit+=6;</tag></item>
                    <item>six<tag>out.digit+=5;</tag></item>
                    <item>7<tag>out.digit+=7;</tag></item>
                    <item>seven<tag>out.digit+=7;</tag></item>
                    <item>8<tag>out.digit+=8;</tag></item>
                    <item>eight<tag>out.digit+=8;</tag></item>
                    <item>9<tag>out.digit+=9;</tag></item>
                    <item>nine<tag>out.digit+=9;</tag></item>
                </one-of>
            </item>
        </rule>
</grammar>
```

### 신용 카드 유효 기간
<a name="telecom-credit"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="dateCardExpiration"
         mode="voice"
         tag-format="semantics/1.0">

        <rule id="dateCardExpiration" scope="public">
            <tag>out=""</tag>
            <item repeat="1"><ruleref uri="#months"/><tag>out = out + rules.months;</tag></item>
            <item repeat="1"><ruleref uri="#year"/><tag>out += " " + rules.year.yr;</tag></item>
        </rule>

        <!-- Test Cases

        Grammar will support the following inputs:

            Scenario 1:
                Input: My card expiration date is july eleven
                Output: 07 2011

            Scenario 2:
                Input: My card expiration date is may twenty six
                Output: 05 2026

        -->

        <rule id="text">
           <item repeat="0-1"><ruleref uri="#hesitation"/></item>
           <one-of>
              <item repeat="0-1">My card expiration date is </item>
           </one-of>
        </rule>

        <rule id="hesitation">
          <one-of>
             <item>Hmm</item>
             <item>Mmm</item>
             <item>My</item>
          </one-of>
        </rule>

        <rule id="months">
           <item repeat="0-1"><ruleref uri="#text"/></item>
           <one-of>
               <item>january<tag>out="01";</tag></item>
               <item>february<tag>out="02";</tag></item>
               <item>march<tag>out="03";</tag></item>
               <item>april<tag>out="04";</tag></item>
               <item>may<tag>out="05";</tag></item>
               <item>june<tag>out="06";</tag></item>
               <item>july<tag>out="07";</tag></item>
               <item>august<tag>out="08";</tag></item>
               <item>september<tag>out="09";</tag></item>
               <item>october<tag>out="10";</tag></item>
               <item>november<tag>out="11";</tag></item>
               <item>december<tag>out="12";</tag></item>
               <item>jan<tag>out="01";</tag></item>
               <item>feb<tag>out="02";</tag></item>
               <item>aug<tag>out="08";</tag></item>
               <item>sept<tag>out="09";</tag></item>
               <item>oct<tag>out="10";</tag></item>
               <item>nov<tag>out="11";</tag></item>
               <item>dec<tag>out="12";</tag></item>
               <item>1<tag>out="01";</tag></item>
               <item>2<tag>out="02";</tag></item>
               <item>3<tag>out="03";</tag></item>
               <item>4<tag>out="04";</tag></item>
               <item>5<tag>out="05";</tag></item>
               <item>6<tag>out="06";</tag></item>
               <item>7<tag>out="07";</tag></item>
               <item>8<tag>out="08";</tag></item>
               <item>9<tag>out="09";</tag></item>
               <item>ten<tag>out="10";</tag></item>
               <item>eleven<tag>out="11";</tag></item>
               <item>twelve<tag>out="12";</tag></item>
           </one-of>
       </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>0<tag>out=0;</tag></item>
                <item>1<tag>out=1;</tag></item>
                <item>2<tag>out=2;</tag></item>
                <item>3<tag>out=3;</tag></item>
                <item>4<tag>out=4;</tag></item>
                <item>5<tag>out=5;</tag></item>
                <item>6<tag>out=6;</tag></item>
                <item>7<tag>out=7;</tag></item>
                <item>8<tag>out=8;</tag></item>
                <item>9<tag>out=9;</tag></item>
                <item>one<tag>out=1;</tag></item>
                <item>two<tag>out=2;</tag></item>
                <item>three<tag>out=3;</tag></item>
                <item>four<tag>out=4;</tag></item>
                <item>five<tag>out=5;</tag></item>
                <item>six<tag>out=6;</tag></item>
                <item>seven<tag>out=7;</tag></item>
                <item>eight<tag>out=8;</tag></item>
                <item>nine<tag>out=9;</tag></item>
            </one-of>
        </rule>

        <rule id="year">
          <tag>out.yr="20"</tag>
          <one-of>
              <item><ruleref uri="#teens"/><tag>out.yr += rules.teens;</tag></item>
              <item><ruleref uri="#above_twenty"/><tag>out.yr += rules.above_twenty;</tag></item>
          </one-of>
        </rule>

        <rule id="teens">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>ten<tag>out=10;</tag></item>
                <item>eleven<tag>out=11;</tag></item>
                <item>twelve<tag>out=12;</tag></item>
                <item>thirteen<tag>out=13;</tag></item>
                <item>fourteen<tag>out=14;</tag></item>
                <item>fifteen<tag>out=15;</tag></item>
                <item>sixteen<tag>out=16;</tag></item>
                <item>seventeen<tag>out=17;</tag></item>
                <item>eighteen<tag>out=18;</tag></item>
                <item>nineteen<tag>out=19;</tag></item>
                <item>10<tag>out=10;</tag></item>
                <item>11<tag>out=11;</tag></item>
                <item>12<tag>out=12;</tag></item>
                <item>13<tag>out=13;</tag></item>
                <item>14<tag>out=14;</tag></item>
                <item>15<tag>out=15;</tag></item>
                <item>16<tag>out=16;</tag></item>
                <item>17<tag>out=17;</tag></item>
                <item>18<tag>out=18;</tag></item>
                <item>19<tag>out=19;</tag></item>
            </one-of>
        </rule>

        <rule id="above_twenty">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>twenty<tag>out=20;</tag></item>
                <item>thirty<tag>out=30;</tag></item>
                <item>forty<tag>out=40;</tag></item>
                <item>fifty<tag>out=50;</tag></item>
                <item>sixty<tag>out=60;</tag></item>
                <item>seventy<tag>out=70;</tag></item>
                <item>eighty<tag>out=80;</tag></item>
                <item>ninety<tag>out=90;</tag></item>
                <item>20<tag>out=20;</tag></item>
                <item>30<tag>out=30;</tag></item>
                <item>40<tag>out=40;</tag></item>
                <item>50<tag>out=50;</tag></item>
                <item>60<tag>out=60;</tag></item>
                <item>70<tag>out=70;</tag></item>
                <item>80<tag>out=80;</tag></item>
                <item>90<tag>out=90;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
        </rule>
</grammar>
```

### 플랜 만료일, 일/월/년
<a name="telecom-ex"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: My plan expires on July Five Two Thousand and Eleven
                 Output: 07/5/11

             Scenario 2:
                 Input: My plan will expire on July Sixteen Two Thousand and Eleven
                 Output: 07/16/11

             Scenario 3:
                 Input: My plan will expire on July Thirty Two Thousand and Eleven
                 Output: 07/30/11
         -->

         <rule id="main" scope="public">
             <tag>out=""</tag>
             <item>
                 <item repeat="1"><ruleref uri="#months"/><tag>out = out + rules.months.mon + "/";</tag></item>
                 <one-of>
                   <item><ruleref uri="#digits"/><tag>out += rules.digits + "/";</tag></item>
                   <item><ruleref uri="#teens"/><tag>out += rules.teens+ "/";</tag></item>
                   <item><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty+ "/";</tag></item>
                 </one-of>
                 <one-of>
                     <item><ruleref uri="#thousands"/><tag>out += rules.thousands;</tag></item>
                     <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
                     <item repeat="0-1"><ruleref uri="#teens"/><tag>out += rules.teens;</tag></item>
                     <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty;</tag></item>
                 </one-of>
             </item>
         </rule>

         <rule id="text">
           <item repeat="0-1"><ruleref uri="#hesitation"/></item>
           <one-of>
                <item repeat="0-1">My plan expires on</item>
                <item repeat="0-1">My plan expired on</item>
                <item repeat="0-1">My plan will expire on</item>
            </one-of>
         </rule>

         <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

         <rule id="months">
            <tag>out.mon=""</tag>
	        <item repeat="0-1"><ruleref uri="#text"/></item>

            <one-of>
              <item>january<tag>out.mon+="01";</tag></item>
              <item>february<tag>out.mon+="02";</tag></item>
              <item>march<tag>out.mon+="03";</tag></item>
              <item>april<tag>out.mon+="04";</tag></item>
              <item>may<tag>out.mon+="05";</tag></item>
              <item>june<tag>out.mon+="06";</tag></item>
              <item>july<tag>out.mon+="07";</tag></item>
              <item>august<tag>out.mon+="08";</tag></item>
              <item>september<tag>out.mon+="09";</tag></item>
              <item>october<tag>out.mon+="10";</tag></item>
              <item>november<tag>out.mon+="11";</tag></item>
              <item>december<tag>out.mon+="12";</tag></item>
              <item>jan<tag>out.mon+="01";</tag></item>
              <item>feb<tag>out.mon+="02";</tag></item>
              <item>aug<tag>out.mon+="08";</tag></item>
              <item>sept<tag>out.mon+="09";</tag></item>
              <item>oct<tag>out.mon+="10";</tag></item>
              <item>nov<tag>out.mon+="11";</tag></item>
              <item>dec<tag>out.mon+="12";</tag></item>
            </one-of>
        </rule>

         <rule id="digits">
             <one-of>
                 <item>zero<tag>out=0;</tag></item>
                 <item>one<tag>out=1;</tag></item>
                 <item>two<tag>out=2;</tag></item>
                 <item>three<tag>out=3;</tag></item>
                 <item>four<tag>out=4;</tag></item>
                 <item>five<tag>out=5;</tag></item>
                 <item>six<tag>out=6;</tag></item>
                 <item>seven<tag>out=7;</tag></item>
                 <item>eight<tag>out=8;</tag></item>
                 <item>nine<tag>out=9;</tag></item>
             </one-of>
         </rule>

         <rule id="teens">
             <one-of>
                 <item>ten<tag>out=10;</tag></item>
                 <item>eleven<tag>out=11;</tag></item>
                 <item>twelve<tag>out=12;</tag></item>
                 <item>thirteen<tag>out=13;</tag></item>
                 <item>fourteen<tag>out=14;</tag></item>
                 <item>fifteen<tag>out=15;</tag></item>
                 <item>sixteen<tag>out=16;</tag></item>
                 <item>seventeen<tag>out=17;</tag></item>
                 <item>eighteen<tag>out=18;</tag></item>
                 <item>nineteen<tag>out=19;</tag></item>
             </one-of>
         </rule>

         <rule id="thousands">
             <item>two thousand</item>
             <item repeat="0-1">and</item>
             <item repeat="0-1"><ruleref uri="#digits"/><tag>out = rules.digits;</tag></item>
             <item repeat="0-1"><ruleref uri="#teens"/><tag>out = rules.teens;</tag></item>
             <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out = rules.above_twenty;</tag></item>
         </rule>

         <rule id="above_twenty">
             <one-of>
                 <item>twenty<tag>out=20;</tag></item>
                 <item>thirty<tag>out=30;</tag></item>
             </one-of>
             <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
         </rule>
 </grammar>
```

### 플랜 갱신일, 월/년
<a name="telecom-renew"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: My plan will renew on July Two Thousand and Eleven
                 Output: 07/11

             Scenario 2:
                 Input: Renew plan on July Two Thousand and Eleven
                 Output: 07/11

         -->

        <rule id="main" scope="public">
            <tag>out=""</tag>
            <item repeat="1-10">
                <item repeat="1"><ruleref uri="#months"/><tag>out = out + rules.months.mon + "/";</tag></item>
                <one-of>
                    <item><ruleref uri="#thousands"/><tag>out += rules.thousands;</tag></item>
                    <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
                    <item repeat="0-1"><ruleref uri="#teens"/><tag>out += rules.teens;</tag></item>
                    <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty;</tag></item>
                </one-of>
            </item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
            <one-of>
                <item repeat="0-1">My plan will renew on</item>
                <item repeat="0-1">My plan was renewed on</item>
                <item repeat="0-1">Renew plan on</item>
            </one-of>
        </rule>

        <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

        <rule id="months">
           <item repeat="0-1"><ruleref uri="#text"/></item>
           <tag>out.mon=""</tag>
           <one-of>
               <item>january<tag>out.mon+="01";</tag></item>
               <item>february<tag>out.mon+="02";</tag></item>
               <item>march<tag>out.mon+="03";</tag></item>
               <item>april<tag>out.mon+="04";</tag></item>
               <item>may<tag>out.mon+="05";</tag></item>
               <item>june<tag>out.mon+="06";</tag></item>
               <item>july<tag>out.mon+="07";</tag></item>
               <item>august<tag>out.mon+="08";</tag></item>
               <item>september<tag>out.mon+="09";</tag></item>
               <item>october<tag>out.mon+="10";</tag></item>
               <item>november<tag>out.mon+="11";</tag></item>
               <item>december<tag>out.mon+="12";</tag></item>
               <item>jan<tag>out.mon+="01";</tag></item>
               <item>feb<tag>out.mon+="02";</tag></item>
               <item>aug<tag>out.mon+="08";</tag></item>
               <item>sept<tag>out.mon+="09";</tag></item>
               <item>oct<tag>out.mon+="10";</tag></item>
               <item>nov<tag>out.mon+="11";</tag></item>
               <item>dec<tag>out.mon+="12";</tag></item>
           </one-of>
       </rule>

        <rule id="digits">
            <one-of>
                <item>zero<tag>out=0;</tag></item>
                <item>one<tag>out=1;</tag></item>
                <item>two<tag>out=2;</tag></item>
                <item>three<tag>out=3;</tag></item>
                <item>four<tag>out=4;</tag></item>
                <item>five<tag>out=5;</tag></item>
                <item>six<tag>out=6;</tag></item>
                <item>seven<tag>out=7;</tag></item>
                <item>eight<tag>out=8;</tag></item>
                <item>nine<tag>out=9;</tag></item>
            </one-of>
        </rule>

        <rule id="teens">
            <one-of>
                <item>ten<tag>out=10;</tag></item>
                <item>eleven<tag>out=11;</tag></item>
                <item>twelve<tag>out=12;</tag></item>
                <item>thirteen<tag>out=13;</tag></item>
                <item>fourteen<tag>out=14;</tag></item>
                <item>fifteen<tag>out=15;</tag></item>
                <item>sixteen<tag>out=16;</tag></item>
                <item>seventeen<tag>out=17;</tag></item>
                <item>eighteen<tag>out=18;</tag></item>
                <item>nineteen<tag>out=19;</tag></item>
            </one-of>
        </rule>

        <rule id="thousands">
            <item>two thousand</item>
            <item repeat="0-1">and</item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out = rules.digits;</tag></item>
            <item repeat="0-1"><ruleref uri="#teens"/><tag>out = rules.teens;</tag></item>
            <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out = rules.above_twenty;</tag></item>
        </rule>

        <rule id="above_twenty">
            <one-of>
                <item>twenty<tag>out=20;</tag></item>
                <item>thirty<tag>out=30;</tag></item>
                <item>forty<tag>out=40;</tag></item>
                <item>fifty<tag>out=50;</tag></item>
                <item>sixty<tag>out=60;</tag></item>
                <item>seventy<tag>out=70;</tag></item>
                <item>eighty<tag>out=80;</tag></item>
                <item>ninety<tag>out=90;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
        </rule>
</grammar>
```

### 플랜 시작일, 월/일
<a name="telecom-start"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: My plan will start on july twenty three
                 Output: 07/23

             Scenario 2:
                 Input: My plan will start on july fifteen
                 Output: 07/15

         -->

        <rule id="main" scope="public">
            <tag>out=""</tag>
            <item repeat="1-10">
                <item><ruleref uri="#months"/><tag>out= rules.months.mon + "/";</tag></item>
                <one-of>
                    <item><ruleref uri="#digits"/><tag>out+= rules.digits;</tag></item>
                    <item><ruleref uri="#teens"/><tag>out+= rules.teens;</tag></item>
                    <item><ruleref uri="#above_twenty"/><tag>out+= rules.above_twenty;</tag></item>
                </one-of>
            </item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
             <one-of>
                <item repeat="0-1">My plan started on</item>
                <item repeat="0-1">My plan will start on</item>
                <item repeat="0-1">I paid it on</item>
                <item repeat="0-1">I paid bill for</item>
             </one-of>
          </rule>
 
          <rule id="hesitation">
             <one-of>
                <item>Hmm</item>
                <item>Mmm</item>
                <item>My</item>
             </one-of>
           </rule>

        <rule id="months">
           <item repeat="0-1"><ruleref uri="#text"/></item>
           <tag>out.mon=""</tag>
           <one-of>
               <item>january<tag>out.mon+="01";</tag></item>
               <item>february<tag>out.mon+="02";</tag></item>
               <item>march<tag>out.mon+="03";</tag></item>
               <item>april<tag>out.mon+="04";</tag></item>
               <item>may<tag>out.mon+="05";</tag></item>
               <item>june<tag>out.mon+="06";</tag></item>
               <item>july<tag>out.mon+="07";</tag></item>
               <item>august<tag>out.mon+="08";</tag></item>
               <item>september<tag>out.mon+="09";</tag></item>
               <item>october<tag>out.mon+="10";</tag></item>
               <item>november<tag>out.mon+="11";</tag></item>
               <item>december<tag>out.mon+="12";</tag></item>
               <item>jan<tag>out.mon+="01";</tag></item>
               <item>feb<tag>out.mon+="02";</tag></item>
               <item>aug<tag>out.mon+="08";</tag></item>
               <item>sept<tag>out.mon+="09";</tag></item>
               <item>oct<tag>out.mon+="10";</tag></item>
               <item>nov<tag>out.mon+="11";</tag></item>
               <item>dec<tag>out.mon+="12";</tag></item>
           </one-of>
        </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>0<tag>out=0;</tag></item>
                <item>1<tag>out=1;</tag></item>
                <item>2<tag>out=2;</tag></item>
                <item>3<tag>out=3;</tag></item>
                <item>4<tag>out=4;</tag></item>
                <item>5<tag>out=5;</tag></item>
                <item>6<tag>out=6;</tag></item>
                <item>7<tag>out=7;</tag></item>
                <item>8<tag>out=8;</tag></item>
                <item>9<tag>out=9;</tag></item>
                <item>first<tag>out=01;</tag></item>
                <item>second<tag>out=02;</tag></item>
                <item>third<tag>out=03;</tag></item>
                <item>fourth<tag>out=04;</tag></item>
                <item>fifth<tag>out=05;</tag></item>
                <item>sixth<tag>out=06;</tag></item>
                <item>seventh<tag>out=07;</tag></item>
                <item>eighth<tag>out=08;</tag></item>
                <item>ninth<tag>out=09;</tag></item>
                <item>one<tag>out=1;</tag></item>
                <item>two<tag>out=2;</tag></item>
                <item>three<tag>out=3;</tag></item>
                <item>four<tag>out=4;</tag></item>
                <item>five<tag>out=5;</tag></item>
                <item>six<tag>out=6;</tag></item>
                <item>seven<tag>out=7;</tag></item>
                <item>eight<tag>out=8;</tag></item>
                <item>nine<tag>out=9;</tag></item>
            </one-of>
        </rule>

        <rule id="teens">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>ten<tag>out=10;</tag></item>
                <item>tenth<tag>out=10;</tag></item>
                <item>eleven<tag>out=11;</tag></item>
                <item>twelve<tag>out=12;</tag></item>
                <item>thirteen<tag>out=13;</tag></item>
                <item>fourteen<tag>out=14;</tag></item>
                <item>fifteen<tag>out=15;</tag></item>
                <item>sixteen<tag>out=16;</tag></item>
                <item>seventeen<tag>out=17;</tag></item>
                <item>eighteen<tag>out=18;</tag></item>
                <item>nineteen<tag>out=19;</tag></item>
                <item>tenth<tag>out=10;</tag></item>
                <item>eleventh<tag>out=11;</tag></item>
                <item>twelveth<tag>out=12;</tag></item>
                <item>thirteenth<tag>out=13;</tag></item>
                <item>fourteenth<tag>out=14;</tag></item>
                <item>fifteenth<tag>out=15;</tag></item>
                <item>sixteenth<tag>out=16;</tag></item>
                <item>seventeenth<tag>out=17;</tag></item>
                <item>eighteenth<tag>out=18;</tag></item>
                <item>nineteenth<tag>out=19;</tag></item>
            </one-of>
        </rule>

        <rule id="above_twenty">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>twenty<tag>out=20;</tag></item>
                <item>thirty<tag>out=30;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
        </rule>
</grammar>
```

### 서비스 시작일, 월/일
<a name="telecom-service"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: My plan starts on july twenty three
                 Output: 07/23

             Scenario 2:
                 Input: I want to activate on july fifteen
                 Output: 07/15

         -->

        <rule id="main" scope="public">
            <tag>out=""</tag>
            <item repeat="1-10">
                <item><ruleref uri="#months"/><tag>out= rules.months.mon + "/";</tag></item>
                <one-of>
                    <item><ruleref uri="#digits"/><tag>out+= rules.digits;</tag></item>
                    <item><ruleref uri="#teens"/><tag>out+= rules.teens;</tag></item>
                    <item><ruleref uri="#above_twenty"/><tag>out+= rules.above_twenty;</tag></item>
                </one-of>
            </item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
             <one-of>
                <item repeat="0-1">My plan starts on</item>
                <item repeat="0-1">I want to start my plan on</item>
                <item repeat="0-1">Activation date of</item>
                <item repeat="0-1">Start activation on</item>
                <item repeat="0-1">I want to activate on</item>
                <item repeat="0-1">Activate plan starting</item>
                <item repeat="0-1">Starting</item>
                <item repeat="0-1">Start on</item>
             </one-of>
          </rule>

          <rule id="hesitation">
             <one-of>
                <item>Hmm</item>
                <item>Mmm</item>
                <item>My</item>
             </one-of>
           </rule>

        <rule id="months">
           <item repeat="0-1"><ruleref uri="#text"/></item>
           <tag>out.mon=""</tag>
           <one-of>
               <item>january<tag>out.mon+="01";</tag></item>
               <item>february<tag>out.mon+="02";</tag></item>
               <item>march<tag>out.mon+="03";</tag></item>
               <item>april<tag>out.mon+="04";</tag></item>
               <item>may<tag>out.mon+="05";</tag></item>
               <item>june<tag>out.mon+="06";</tag></item>
               <item>july<tag>out.mon+="07";</tag></item>
               <item>august<tag>out.mon+="08";</tag></item>
               <item>september<tag>out.mon+="09";</tag></item>
               <item>october<tag>out.mon+="10";</tag></item>
               <item>november<tag>out.mon+="11";</tag></item>
               <item>december<tag>out.mon+="12";</tag></item>
               <item>jan<tag>out.mon+="01";</tag></item>
               <item>feb<tag>out.mon+="02";</tag></item>
               <item>aug<tag>out.mon+="08";</tag></item>
               <item>sept<tag>out.mon+="09";</tag></item>
               <item>oct<tag>out.mon+="10";</tag></item>
               <item>nov<tag>out.mon+="11";</tag></item>
               <item>dec<tag>out.mon+="12";</tag></item>
           </one-of>
        </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>0<tag>out=0;</tag></item>
                <item>1<tag>out=1;</tag></item>
                <item>2<tag>out=2;</tag></item>
                <item>3<tag>out=3;</tag></item>
                <item>4<tag>out=4;</tag></item>
                <item>5<tag>out=5;</tag></item>
                <item>6<tag>out=6;</tag></item>
                <item>7<tag>out=7;</tag></item>
                <item>8<tag>out=8;</tag></item>
                <item>9<tag>out=9;</tag></item>
                <item>first<tag>out=01;</tag></item>
                <item>second<tag>out=02;</tag></item>
                <item>third<tag>out=03;</tag></item>
                <item>fourth<tag>out=04;</tag></item>
                <item>fifth<tag>out=05;</tag></item>
                <item>sixth<tag>out=06;</tag></item>
                <item>seventh<tag>out=07;</tag></item>
                <item>eighth<tag>out=08;</tag></item>
                <item>ninth<tag>out=09;</tag></item>
                <item>one<tag>out=1;</tag></item>
                <item>two<tag>out=2;</tag></item>
                <item>three<tag>out=3;</tag></item>
                <item>four<tag>out=4;</tag></item>
                <item>five<tag>out=5;</tag></item>
                <item>six<tag>out=6;</tag></item>
                <item>seven<tag>out=7;</tag></item>
                <item>eight<tag>out=8;</tag></item>
                <item>nine<tag>out=9;</tag></item>
            </one-of>
        </rule>

        <rule id="teens">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>ten<tag>out=10;</tag></item>
                <item>tenth<tag>out=10;</tag></item>
                <item>eleven<tag>out=11;</tag></item>
                <item>twelve<tag>out=12;</tag></item>
                <item>thirteen<tag>out=13;</tag></item>
                <item>fourteen<tag>out=14;</tag></item>
                <item>fifteen<tag>out=15;</tag></item>
                <item>sixteen<tag>out=16;</tag></item>
                <item>seventeen<tag>out=17;</tag></item>
                <item>eighteen<tag>out=18;</tag></item>
                <item>nineteen<tag>out=19;</tag></item>
                <item>tenth<tag>out=10;</tag></item>
                <item>eleventh<tag>out=11;</tag></item>
                <item>twelveth<tag>out=12;</tag></item>
                <item>thirteenth<tag>out=13;</tag></item>
                <item>fourteenth<tag>out=14;</tag></item>
                <item>fifteenth<tag>out=15;</tag></item>
                <item>sixteenth<tag>out=16;</tag></item>
                <item>seventeenth<tag>out=17;</tag></item>
                <item>eighteenth<tag>out=18;</tag></item>
                <item>nineteenth<tag>out=19;</tag></item>
            </one-of>
        </rule>

        <rule id="above_twenty">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>twenty<tag>out=20;</tag></item>
                <item>thirty<tag>out=30;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
        </rule>
</grammar>
```

### 장비 수량
<a name="telecom-equipment"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

             Scenario 1:
                 Input: The number is one
                 Output: 1

             Scenario 2:
                 Input: It is ten
                 Output: 10

         -->

        <rule id="main" scope="public">
            <tag>out=""</tag>
            <one-of>
              <item repeat="1"><ruleref uri="#digits"/><tag>out+= rules.digits;</tag></item>
              <item repeat="1"><ruleref uri="#teens"/><tag>out+= rules.teens;</tag></item>
              <item repeat="1"><ruleref uri="#above_twenty"/><tag>out+= rules.above_twenty;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#thanks"/></item>
        </rule>

        <rule id="text">
            <item repeat="0-1"><ruleref uri="#hesitation"/></item>
           <one-of>
              <item repeat="0-1">It is</item>
              <item repeat="0-1">The number is</item>
              <item repeat="0-1">Order</item>
              <item repeat="0-1">I want to order</item>
              <item repeat="0-1">Total equipment</item>
           </one-of>
        </rule>

        <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

        <rule id="thanks">
            <one-of>
               <item>Thanks</item>
               <item>I think</item>
            </one-of>
          </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>0<tag>out=0;</tag></item>
                <item>1<tag>out=1;</tag></item>
                <item>2<tag>out=2;</tag></item>
                <item>3<tag>out=3;</tag></item>
                <item>4<tag>out=4;</tag></item>
                <item>5<tag>out=5;</tag></item>
                <item>6<tag>out=6;</tag></item>
                <item>7<tag>out=7;</tag></item>
                <item>8<tag>out=8;</tag></item>
                <item>9<tag>out=9;</tag></item>
                <item>one<tag>out=1;</tag></item>
                <item>two<tag>out=2;</tag></item>
                <item>three<tag>out=3;</tag></item>
                <item>four<tag>out=4;</tag></item>
                <item>five<tag>out=5;</tag></item>
                <item>six<tag>out=6;</tag></item>
                <item>seven<tag>out=7;</tag></item>
                <item>eight<tag>out=8;</tag></item>
                <item>nine<tag>out=9;</tag></item>
            </one-of>
        </rule>

        <rule id="teens">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>ten<tag>out=10;</tag></item>
                <item>eleven<tag>out=11;</tag></item>
                <item>twelve<tag>out=12;</tag></item>
                <item>thirteen<tag>out=13;</tag></item>
                <item>fourteen<tag>out=14;</tag></item>
                <item>fifteen<tag>out=15;</tag></item>
                <item>sixteen<tag>out=16;</tag></item>
                <item>seventeen<tag>out=17;</tag></item>
                <item>eighteen<tag>out=18;</tag></item>
                <item>nineteen<tag>out=19;</tag></item>
                <item>10<tag>out=10;</tag></item>
                <item>11<tag>out=11;</tag></item>
                <item>12<tag>out=12;</tag></item>
                <item>13<tag>out=13;</tag></item>
                <item>14<tag>out=14;</tag></item>
                <item>15<tag>out=15;</tag></item>
                <item>16<tag>out=16;</tag></item>
                <item>17<tag>out=17;</tag></item>
                <item>18<tag>out=18;</tag></item>
                <item>19<tag>out=19;</tag></item>
            </one-of>
        </rule>

        <rule id="above_twenty">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <one-of>
                <item>twenty<tag>out=20;</tag></item>
                <item>thirty<tag>out=30;</tag></item>
                <item>forty<tag>out=40;</tag></item>
                <item>fifty<tag>out=50;</tag></item>
                <item>sixty<tag>out=60;</tag></item>
                <item>seventy<tag>out=70;</tag></item>
                <item>eighty<tag>out=80;</tag></item>
                <item>ninety<tag>out=90;</tag></item>
                <item>20<tag>out=20;</tag></item>
                <item>30<tag>out=30;</tag></item>
                <item>40<tag>out=40;</tag></item>
                <item>50<tag>out=50;</tag></item>
                <item>60<tag>out=60;</tag></item>
                <item>70<tag>out=70;</tag></item>
                <item>80<tag>out=80;</tag></item>
                <item>90<tag>out=90;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
        </rule>

</grammar>
```

### 청구서 금액
<a name="telecom-bill"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <!-- Test Cases

         Grammar will support the following inputs:

                 Input: I want to make a payment of one hundred ten dollars
                 Output: $110

         -->

        <rule id="main" scope="public">
            <tag>out="$"</tag>
            <one-of>
                <item><ruleref uri="#sub_hundred"/><tag>out += rules.sub_hundred.sh;</tag></item>
                <item><ruleref uri="#subThousands"/><tag>out += rules.subThousands;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#thanks"/></item>
        </rule>

        <rule id="text">
           <item repeat="0-1"><ruleref uri="#hesitation"/></item>
           <one-of>
              <item repeat="0-1">I want to make a payment for</item>
              <item repeat="0-1">I want to make a payment of</item>
              <item repeat="0-1">Pay a total of</item>
              <item repeat="0-1">Paying</item>
              <item repeat="0-1">Pay bill for </item>
           </one-of>
        </rule>

        <rule id="hesitation">
            <one-of>
               <item>Hmm</item>
               <item>Mmm</item>
               <item>My</item>
            </one-of>
          </rule>

          <rule id="thanks">
              <one-of>
                 <item>Thanks</item>
                 <item>I think</item>
              </one-of>
            </rule>

        <rule id="digits">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.num = 0;</tag>
            <one-of>
                <item>0<tag>out.num+=0;</tag></item>
                <item>1<tag>out.num+=1;</tag></item>
                <item>2<tag>out.num+=2;</tag></item>
                <item>3<tag>out.num+=3;</tag></item>
                <item>4<tag>out.num+=4;</tag></item>
                <item>5<tag>out.num+=5;</tag></item>
                <item>6<tag>out.num+=6;</tag></item>
                <item>7<tag>out.num+=7;</tag></item>
                <item>8<tag>out.num+=8;</tag></item>
                <item>9<tag>out.num+=9;</tag></item>
                <item>one<tag>out.num+=1;</tag></item>
                <item>two<tag>out.num+=2;</tag></item>
                <item>three<tag>out.num+=3;</tag></item>
                <item>four<tag>out.num+=4;</tag></item>
                <item>five<tag>out.num+=5;</tag></item>
                <item>six<tag>out.num+=6;</tag></item>
                <item>seven<tag>out.num+=7;</tag></item>
                <item>eight<tag>out.num+=8;</tag></item>
                <item>nine<tag>out.num+=9;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
        </rule>

        <rule id="teens">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.teen = 0;</tag>
            <one-of>
                <item>ten<tag>out.teen+=10;</tag></item>
                <item>eleven<tag>out.teen+=11;</tag></item>
                <item>twelve<tag>out.teen+=12;</tag></item>
                <item>thirteen<tag>out.teen+=13;</tag></item>
                <item>fourteen<tag>out.teen+=14;</tag></item>
                <item>fifteen<tag>out.teen+=15;</tag></item>
                <item>sixteen<tag>out.teen+=16;</tag></item>
                <item>seventeen<tag>out.teen+=17;</tag></item>
                <item>eighteen<tag>out.teen+=18;</tag></item>
                <item>nineteen<tag>out.teen+=19;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
        </rule>

        <rule id="above_twenty">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.tens = 0;</tag>
            <one-of>
                <item>twenty<tag>out.tens+=20;</tag></item>
                <item>thirty<tag>out.tens+=30;</tag></item>
                <item>forty<tag>out.tens+=40;</tag></item>
                <item>fifty<tag>out.tens+=50;</tag></item>
                <item>sixty<tag>out.tens+=60;</tag></item>
                <item>seventy<tag>out.tens+=70;</tag></item>
                <item>eighty<tag>out.tens+=80;</tag></item>
                <item>ninety<tag>out.tens+=90;</tag></item>
                <item>hundred<tag>out.tens+=100;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out.tens += rules.digits.num;</tag></item>
        </rule>

        <rule id="currency">
            <one-of>
                <item repeat="0-1">dollars</item>
                <item repeat="0-1">Dollars</item>
                <item repeat="0-1">dollar</item>
                <item repeat="0-1">Dollar</item>
            </one-of>
        </rule>


        <rule id="sub_hundred">
            <item repeat="0-1"><ruleref uri="#text"/></item>
            <tag>out.sh = 0;</tag>
            <one-of>
                <item><ruleref uri="#teens"/><tag>out.sh += rules.teens.teen;</tag></item>
                <item>
                    <ruleref uri="#above_twenty"/><tag>out.sh += rules.above_twenty.tens;</tag>
                </item>
                <item><ruleref uri="#digits"/><tag>out.sh += rules.digits.num;</tag></item>
            </one-of>
         </rule>

        <rule id="subThousands">
            <ruleref uri="#sub_hundred"/><tag>out = (100 * rules.sub_hundred.sh);</tag>
            hundred
            <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty.tens;</tag></item>
            <item repeat="0-1"><ruleref uri="#teens"/><tag>out += rules.teens.teen;</tag></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits.num;</tag></item>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
        </rule>
</grammar>
```

## 일반 문법([다운로드](samples/generic-grammars.zip))
<a name="generic-grammars"></a>

영숫자, 통화, 날짜(mm/dd/yy), 숫자, 인사말, 망설임, 에이전트 등의 일반 문법을 제공합니다.

### 영숫자
<a name="generic-alpha"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">


        <!-- Test Cases

            Scenario 1:
                Input: A B C 1 2 3 4
                Output: ABC1234 

            Scenario 2:
                Input: 1 2 3 4 A B C 
                Output: 1234ABC

            Scenario 3:
                Input: 1 2 3 4 A B C 1
                Output: 123ABC1
        --> 

        <rule id="main" scope="public">
            <tag>out=""</tag>
            <item><ruleref uri="#alphanumeric"/><tag>out += rules.alphanumeric.alphanum;</tag></item>
            <item repeat="0-1"><ruleref uri="#alphabets"/><tag>out += rules.alphabets.letters;</tag></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits.numbers</tag></item>
        </rule>

        <rule id="alphanumeric" scope="public">
            <tag>out.alphanum=""</tag>
            <item><ruleref uri="#alphabets"/><tag>out.alphanum += rules.alphabets.letters;</tag></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out.alphanum += rules.digits.numbers</tag></item>
        </rule>
        
        <rule id="alphabets">   
            <tag>out.letters=""</tag>
            <tag>out.firstOccurence=""</tag>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out.firstOccurence += rules.digits.numbers; out.letters += out.firstOccurence;</tag></item>
            <item repeat="1-">
                <one-of> 
                    <item>A<tag>out.letters+='A';</tag></item>
                    <item>B<tag>out.letters+='B';</tag></item>
                    <item>C<tag>out.letters+='C';</tag></item>
                    <item>D<tag>out.letters+='D';</tag></item>
                    <item>E<tag>out.letters+='E';</tag></item>
                    <item>F<tag>out.letters+='F';</tag></item>
                    <item>G<tag>out.letters+='G';</tag></item>
                    <item>H<tag>out.letters+='H';</tag></item>
                    <item>I<tag>out.letters+='I';</tag></item>
                    <item>J<tag>out.letters+='J';</tag></item>
                    <item>K<tag>out.letters+='K';</tag></item>
                    <item>L<tag>out.letters+='L';</tag></item>
                    <item>M<tag>out.letters+='M';</tag></item>
                    <item>N<tag>out.letters+='N';</tag></item>
                    <item>O<tag>out.letters+='O';</tag></item>
                    <item>P<tag>out.letters+='P';</tag></item>
                    <item>Q<tag>out.letters+='Q';</tag></item>
                    <item>R<tag>out.letters+='R';</tag></item>
                    <item>S<tag>out.letters+='S';</tag></item>
                    <item>T<tag>out.letters+='T';</tag></item>
                    <item>U<tag>out.letters+='U';</tag></item>
                    <item>V<tag>out.letters+='V';</tag></item>
                    <item>W<tag>out.letters+='W';</tag></item>
                    <item>X<tag>out.letters+='X';</tag></item>
                    <item>Y<tag>out.letters+='Y';</tag></item>
                    <item>Z<tag>out.letters+='Z';</tag></item>
                </one-of>
            </item>
        </rule> 

        <rule id="digits">   
            <tag>out.numbers=""</tag>
            <item repeat="1-10">
                <one-of> 
                    <item>0<tag>out.numbers+=0;</tag></item>
                    <item>1<tag>out.numbers+=1;</tag></item>
                    <item>2<tag>out.numbers+=2;</tag></item>
                    <item>3<tag>out.numbers+=3;</tag></item>
                    <item>4<tag>out.numbers+=4;</tag></item>
                    <item>5<tag>out.numbers+=5;</tag></item>
                    <item>6<tag>out.numbers+=6;</tag></item>
                    <item>7<tag>out.numbers+=7;</tag></item>
                    <item>8<tag>out.numbers+=8;</tag></item>
                    <item>9<tag>out.numbers+=9;</tag></item>
                </one-of>
            </item>
        </rule> 
</grammar>
```

### 통화
<a name="generic-currency"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

        <rule id="main" scope="public">
            <tag>out="$"</tag>
            <one-of>
                <item><ruleref uri="#sub_hundred"/><tag>out += rules.sub_hundred.sh;</tag></item> 
                <item><ruleref uri="#subThousands"/><tag>out += rules.subThousands;</tag></item>
            </one-of>
        </rule>

        <rule id="digits">
            <tag>out.num = 0;</tag>
            <one-of>
                <item>0<tag>out.num+=0;</tag></item>
                <item>1<tag>out.num+=1;</tag></item>
                <item>2<tag>out.num+=2;</tag></item>
                <item>3<tag>out.num+=3;</tag></item>
                <item>4<tag>out.num+=4;</tag></item>
                <item>5<tag>out.num+=5;</tag></item>
                <item>6<tag>out.num+=6;</tag></item>
                <item>7<tag>out.num+=7;</tag></item>
                <item>8<tag>out.num+=8;</tag></item>
                <item>9<tag>out.num+=9;</tag></item>
                <item>one<tag>out.num+=1;</tag></item>
                <item>two<tag>out.num+=2;</tag></item>
                <item>three<tag>out.num+=3;</tag></item>
                <item>four<tag>out.num+=4;</tag></item>
                <item>five<tag>out.num+=5;</tag></item>
                <item>six<tag>out.num+=6;</tag></item>
                <item>seven<tag>out.num+=7;</tag></item>
                <item>eight<tag>out.num+=8;</tag></item>
                <item>nine<tag>out.num+=9;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
        </rule>

        <rule id="teens">
            <tag>out.teen = 0;</tag>
            <one-of>
                <item>ten<tag>out.teen+=10;</tag></item>
                <item>eleven<tag>out.teen+=11;</tag></item>
                <item>twelve<tag>out.teen+=12;</tag></item>
                <item>thirteen<tag>out.teen+=13;</tag></item>
                <item>fourteen<tag>out.teen+=14;</tag></item>
                <item>fifteen<tag>out.teen+=15;</tag></item>
                <item>sixteen<tag>out.teen+=16;</tag></item>
                <item>seventeen<tag>out.teen+=17;</tag></item>
                <item>eighteen<tag>out.teen+=18;</tag></item>
                <item>nineteen<tag>out.teen+=19;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
        </rule>

        <rule id="above_twenty">
            <tag>out.tens = 0;</tag>
            <one-of>
                <item>twenty<tag>out.tens+=20;</tag></item>
                <item>thirty<tag>out.tens+=30;</tag></item>
                <item>forty<tag>out.tens+=40;</tag></item>
                <item>fifty<tag>out.tens+=50;</tag></item>
                <item>sixty<tag>out.tens+=60;</tag></item>
                <item>seventy<tag>out.tens+=70;</tag></item>
                <item>eighty<tag>out.tens+=80;</tag></item>
                <item>ninety<tag>out.tens+=90;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#currency"/></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out.tens += rules.digits.num;</tag></item>
        </rule>

        <rule id="currency">
            <one-of>
                <item repeat="0-1">dollars</item>
                <item repeat="0-1">Dollars</item>
                <item repeat="0-1">dollar</item>
                <item repeat="0-1">Dollar</item>
            </one-of>
        </rule>


        <rule id="sub_hundred">
            <tag>out.sh = 0;</tag>
            <one-of>
                <item><ruleref uri="#teens"/><tag>out.sh += rules.teens.teen;</tag></item>
                <item>
                    <ruleref uri="#above_twenty"/><tag>out.sh += rules.above_twenty.tens;</tag>
                </item>
                <item><ruleref uri="#digits"/><tag>out.sh += rules.digits.num;</tag></item>
            </one-of>
         </rule>

        <rule id="subThousands">
            <ruleref uri="#sub_hundred"/><tag>out = (100 * rules.sub_hundred.sh);</tag>
            hundred
            <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty.tens;</tag></item>
            <item repeat="0-1"><ruleref uri="#teens"/><tag>out += rules.teens.teen;</tag></item>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits.num;</tag></item>
        </rule>
</grammar>
```

### 날짜, 일/월
<a name="generic-ddmm"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

        <rule id="main" scope="public">
            <tag>out=""</tag>
            <item repeat="1-10">
                <one-of>
                    <item><ruleref uri="#digits"/><tag>out += rules.digits + " ";</tag></item>
                    <item><ruleref uri="#teens"/><tag>out += rules.teens+ " ";</tag></item>
                    <item><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty+ " ";</tag></item>
                </one-of>
                <item><ruleref uri="#months"/><tag>out = out + rules.months;</tag></item>
            </item>
        </rule>

        <rule id="months">
           <one-of>
             <item>january<tag>out="january";</tag></item>
             <item>february<tag>out="february";</tag></item>
             <item>march<tag>out="march";</tag></item>
             <item>april<tag>out="april";</tag></item>
             <item>may<tag>out="may";</tag></item>
             <item>june<tag>out="june";</tag></item>
             <item>july<tag>out="july";</tag></item>
             <item>august<tag>out="august";</tag></item>
             <item>september<tag>out="september";</tag></item>
             <item>october<tag>out="october";</tag></item>
             <item>november<tag>out="november";</tag></item>
             <item>december<tag>out="december";</tag></item>
             <item>jan<tag>out="january";</tag></item>
             <item>feb<tag>out="february";</tag></item>
             <item>aug<tag>out="august";</tag></item>
             <item>sept<tag>out="september";</tag></item>
             <item>oct<tag>out="october";</tag></item>
             <item>nov<tag>out="november";</tag></item>
             <item>dec<tag>out="december";</tag></item>
           </one-of>
       </rule>

        <rule id="digits">
            <one-of>
                <item>0<tag>out=0;</tag></item>
                <item>1<tag>out=1;</tag></item>
                <item>2<tag>out=2;</tag></item>
                <item>3<tag>out=3;</tag></item>
                <item>4<tag>out=4;</tag></item>
                <item>5<tag>out=5;</tag></item>
                <item>6<tag>out=6;</tag></item>
                <item>7<tag>out=7;</tag></item>
                <item>8<tag>out=8;</tag></item>
                <item>9<tag>out=9;</tag></item>
                <item>first<tag>out=1;</tag></item>
                <item>second<tag>out=2;</tag></item>
                <item>third<tag>out=3;</tag></item>
                <item>fourth<tag>out=4;</tag></item>
                <item>fifth<tag>out=5;</tag></item>
                <item>sixth<tag>out=6;</tag></item>
                <item>seventh<tag>out=7;</tag></item>
                <item>eighth<tag>out=8;</tag></item>
                <item>ninth<tag>out=9;</tag></item>
                <item>one<tag>out=1;</tag></item>
                <item>two<tag>out=2;</tag></item>
                <item>three<tag>out=3;</tag></item>
                <item>four<tag>out=4;</tag></item>
                <item>five<tag>out=5;</tag></item>
                <item>six<tag>out=6;</tag></item>
                <item>seven<tag>out=7;</tag></item>
                <item>eight<tag>out=8;</tag></item>
                <item>nine<tag>out=9;</tag></item>
            </one-of>
        </rule>

        <rule id="teens">
            <one-of>
                <item>ten<tag>out=10;</tag></item>
                <item>tenth<tag>out=10;</tag></item>
                <item>eleven<tag>out=11;</tag></item>
                <item>twelve<tag>out=12;</tag></item>
                <item>thirteen<tag>out=13;</tag></item>
                <item>fourteen<tag>out=14;</tag></item>
                <item>fifteen<tag>out=15;</tag></item>
                <item>sixteen<tag>out=16;</tag></item>
                <item>seventeen<tag>out=17;</tag></item>
                <item>eighteen<tag>out=18;</tag></item>
                <item>nineteen<tag>out=19;</tag></item>
                <item>tenth<tag>out=10;</tag></item>
                <item>eleventh<tag>out=11;</tag></item>
                <item>twelveth<tag>out=12;</tag></item>
                <item>thirteenth<tag>out=13;</tag></item>
                <item>fourteenth<tag>out=14;</tag></item>
                <item>fifteenth<tag>out=15;</tag></item>
                <item>sixteenth<tag>out=16;</tag></item>
                <item>seventeenth<tag>out=17;</tag></item>
                <item>eighteenth<tag>out=18;</tag></item>
                <item>nineteenth<tag>out=19;</tag></item>
            </one-of>
        </rule>

        <rule id="above_twenty">
            <one-of>
                <item>twenty<tag>out=20;</tag></item>
                <item>thirty<tag>out=30;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
        </rule>
</grammar>
```

### 날짜, 월/년
<a name="generic-mmyy"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

        <rule id="main" scope="public">
            <tag>out=""</tag>
            <item repeat="1-10">
                <item repeat="1"><ruleref uri="#months"/><tag>out = out + rules.months.mon + " ";</tag></item>
                <one-of>
                    <item><ruleref uri="#thousands"/><tag>out += rules.thousands;</tag></item>
                    <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
                    <item repeat="0-1"><ruleref uri="#teens"/><tag>out += rules.teens;</tag></item>
                    <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty;</tag></item>
                </one-of>
            </item>
        </rule>

        <rule id="months">
           <tag>out.mon=""</tag>
           <one-of>
               <item>january<tag>out.mon+="january";</tag></item>
               <item>february<tag>out.mon+="february";</tag></item>
               <item>march<tag>out.mon+="march";</tag></item>
               <item>april<tag>out.mon+="april";</tag></item>
               <item>may<tag>out.mon+="may";</tag></item>
               <item>june<tag>out.mon+="june";</tag></item>
               <item>july<tag>out.mon+="july";</tag></item>
               <item>august<tag>out.mon+="august";</tag></item>
               <item>september<tag>out.mon+="september";</tag></item>
               <item>october<tag>out.mon+="october";</tag></item>
               <item>november<tag>out.mon+="november";</tag></item>
               <item>december<tag>out.mon+="december";</tag></item>
               <item>jan<tag>out.mon+="january";</tag></item>
               <item>feb<tag>out.mon+="february";</tag></item>
               <item>aug<tag>out.mon+="august";</tag></item>
               <item>sept<tag>out.mon+="september";</tag></item>
               <item>oct<tag>out.mon+="october";</tag></item>
               <item>nov<tag>out.mon+="november";</tag></item>
               <item>dec<tag>out.mon+="december";</tag></item>
           </one-of>
       </rule>

        <rule id="digits">
            <one-of>
                <item>zero<tag>out=0;</tag></item>
                <item>one<tag>out=1;</tag></item>
                <item>two<tag>out=2;</tag></item>
                <item>three<tag>out=3;</tag></item>
                <item>four<tag>out=4;</tag></item>
                <item>five<tag>out=5;</tag></item>
                <item>six<tag>out=6;</tag></item>
                <item>seven<tag>out=7;</tag></item>
                <item>eight<tag>out=8;</tag></item>
                <item>nine<tag>out=9;</tag></item>
            </one-of>
        </rule>

        <rule id="teens">
            <one-of>
                <item>ten<tag>out=10;</tag></item>
                <item>eleven<tag>out=11;</tag></item>
                <item>twelve<tag>out=12;</tag></item>
                <item>thirteen<tag>out=13;</tag></item>
                <item>fourteen<tag>out=14;</tag></item>
                <item>fifteen<tag>out=15;</tag></item>
                <item>sixteen<tag>out=16;</tag></item>
                <item>seventeen<tag>out=17;</tag></item>
                <item>eighteen<tag>out=18;</tag></item>
                <item>nineteen<tag>out=19;</tag></item>
            </one-of>
        </rule>

       <!--  <rule id="singleDigit">
            <item><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
        </rule> -->

        <rule id="thousands">
            <!-- <item>
                <ruleref uri="#digits"/>
                <tag>out = (1000 * rules.digits);</tag>
                thousand
            </item> -->
            <item>two thousand<tag>out=2000;</tag></item> 
            <item repeat="0-1">and</item> 
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
            <item repeat="0-1"><ruleref uri="#teens"/><tag>out += rules.teens;</tag></item>
            <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty;</tag></item>
        </rule>

        <rule id="above_twenty">
            <one-of>
                <item>twenty<tag>out=20;</tag></item>
                <item>thirty<tag>out=30;</tag></item>
                <item>forty<tag>out=40;</tag></item>
                <item>fifty<tag>out=50;</tag></item>
                <item>sixty<tag>out=60;</tag></item>
                <item>seventy<tag>out=70;</tag></item>
                <item>eighty<tag>out=80;</tag></item>
                <item>ninety<tag>out=90;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
        </rule>

</grammar>
```

### 날짜, 일/월/년
<a name="generic-ddmmyyyy"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <rule id="main" scope="public">
             <tag>out=""</tag>
             <item repeat="1-10">
                 <one-of>
                   <item><ruleref uri="#digits"/><tag>out += rules.digits + " ";</tag></item>
                   <item><ruleref uri="#teens"/><tag>out += rules.teens+ " ";</tag></item>
                   <item><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty+ " ";</tag></item>
                 </one-of>
                 <item repeat="1"><ruleref uri="#months"/><tag>out = out + rules.months.mon + " ";</tag></item>
                 <one-of>
                     <item><ruleref uri="#thousands"/><tag>out += rules.thousands;</tag></item>
                     <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
                     <item repeat="0-1"><ruleref uri="#teens"/><tag>out += rules.teens;</tag></item>
                     <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty;</tag></item>
                 </one-of>
             </item>
         </rule>

         <rule id="months">
            <tag>out.mon=""</tag>
            <one-of>
                <item>january<tag>out.mon+="january";</tag></item>
                <item>february<tag>out.mon+="february";</tag></item>
                <item>march<tag>out.mon+="march";</tag></item>
                <item>april<tag>out.mon+="april";</tag></item>
                <item>may<tag>out.mon+="may";</tag></item>
                <item>june<tag>out.mon+="june";</tag></item>
                <item>july<tag>out.mon+="july";</tag></item>
                <item>august<tag>out.mon+="august";</tag></item>
                <item>september<tag>out.mon+="september";</tag></item>
                <item>october<tag>out.mon+="october";</tag></item>
                <item>november<tag>out.mon+="november";</tag></item>
                <item>december<tag>out.mon+="december";</tag></item>
                <item>jan<tag>out.mon+="january";</tag></item>
                <item>feb<tag>out.mon+="february";</tag></item>
                <item>aug<tag>out.mon+="august";</tag></item>
                <item>sept<tag>out.mon+="september";</tag></item>
                <item>oct<tag>out.mon+="october";</tag></item>
                <item>nov<tag>out.mon+="november";</tag></item>
                <item>dec<tag>out.mon+="december";</tag></item>
            </one-of>
        </rule>

         <rule id="digits">
             <one-of>
                 <item>zero<tag>out=0;</tag></item>
                 <item>one<tag>out=1;</tag></item>
                 <item>two<tag>out=2;</tag></item>
                 <item>three<tag>out=3;</tag></item>
                 <item>four<tag>out=4;</tag></item>
                 <item>five<tag>out=5;</tag></item>
                 <item>six<tag>out=6;</tag></item>
                 <item>seven<tag>out=7;</tag></item>
                 <item>eight<tag>out=8;</tag></item>
                 <item>nine<tag>out=9;</tag></item>
             </one-of>
         </rule>

         <rule id="teens">
             <one-of>
                 <item>ten<tag>out=10;</tag></item>
                 <item>eleven<tag>out=11;</tag></item>
                 <item>twelve<tag>out=12;</tag></item>
                 <item>thirteen<tag>out=13;</tag></item>
                 <item>fourteen<tag>out=14;</tag></item>
                 <item>fifteen<tag>out=15;</tag></item>
                 <item>sixteen<tag>out=16;</tag></item>
                 <item>seventeen<tag>out=17;</tag></item>
                 <item>eighteen<tag>out=18;</tag></item>
                 <item>nineteen<tag>out=19;</tag></item>
             </one-of>
         </rule>

         <rule id="thousands">
             <item>two thousand<tag>out=2000;</tag></item>
             <item repeat="0-1">and</item>
             <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
             <item repeat="0-1"><ruleref uri="#teens"/><tag>out += rules.teens;</tag></item>
             <item repeat="0-1"><ruleref uri="#above_twenty"/><tag>out += rules.above_twenty;</tag></item>
         </rule>

         <rule id="above_twenty">
             <one-of>
                 <item>twenty<tag>out=20;</tag></item>
                 <item>thirty<tag>out=30;</tag></item>
                 <item>forty<tag>out=40;</tag></item>
                 <item>fifty<tag>out=50;</tag></item>
                 <item>sixty<tag>out=60;</tag></item>
                 <item>seventy<tag>out=70;</tag></item>
                 <item>eighty<tag>out=80;</tag></item>
                 <item>ninety<tag>out=90;</tag></item>
             </one-of>
             <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
         </rule>

 </grammar>
```

### 숫자, 자리 수
<a name="generic-digits"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="digits"
         mode="voice"
         tag-format="semantics/1.0">

        <rule id="digits">  
            <tag>out=""</tag>
            <item><ruleref uri="#singleDigit"/><tag>out += rules.singleDigit.digit;</tag></item>
        </rule>

        <rule id="singleDigit"> 
            <tag>out.digit=""</tag>
            <item repeat="1-10">
                <one-of> 
                    <item>0<tag>out.digit+=0;</tag></item>
                    <item>zero<tag>out.digit+=0;</tag></item>
                    <item>1<tag>out.digit+=1;</tag></item>
                    <item>one<tag>out.digit+=1;</tag></item>
                    <item>2<tag>out.digit+=2;</tag></item>
                    <item>two<tag>out.digit+=2;</tag></item>
                    <item>3<tag>out.digit+=3;</tag></item>
                    <item>three<tag>out.digit+=3;</tag></item>
                    <item>4<tag>out.digit+=4;</tag></item>
                    <item>four<tag>out.digit+=4;</tag></item>
                    <item>5<tag>out.digit+=5;</tag></item>
                    <item>five<tag>out.digit+=5;</tag></item>
                    <item>6<tag>out.digit+=6;</tag></item>
                    <item>six<tag>out.digit+=6;</tag></item>
                    <item>7<tag>out.digit+=7;</tag></item>
                    <item>seven<tag>out.digit+=7;</tag></item>
                    <item>8<tag>out.digit+=8;</tag></item>
                    <item>eight<tag>out.digit+=8;</tag></item>
                    <item>9<tag>out.digit+=9;</tag></item>
                    <item>nine<tag>out.digit+=9;</tag></item>
                </one-of>
            </item>
        </rule> 
</grammar>
```

### 숫자, 서수
<a name="generic-ordinal"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

        <rule id="main" scope="public">
            <tag>out=""</tag>
            <one-of>
              <item repeat="1"><ruleref uri="#digits"/><tag>out+= rules.digits;</tag></item>
              <item repeat="1"><ruleref uri="#teens"/><tag>out+= rules.teens;</tag></item>
              <item repeat="1"><ruleref uri="#above_twenty"/><tag>out+= rules.above_twenty;</tag></item>
            </one-of>
        </rule>

        <rule id="digits">
            <one-of>
                <item>0<tag>out=0;</tag></item>
                <item>1<tag>out=1;</tag></item>
                <item>2<tag>out=2;</tag></item>
                <item>3<tag>out=3;</tag></item>
                <item>4<tag>out=4;</tag></item>
                <item>5<tag>out=5;</tag></item>
                <item>6<tag>out=6;</tag></item>
                <item>7<tag>out=7;</tag></item>
                <item>8<tag>out=8;</tag></item>
                <item>9<tag>out=9;</tag></item>
                <item>one<tag>out=1;</tag></item>
                <item>two<tag>out=2;</tag></item>
                <item>three<tag>out=3;</tag></item>
                <item>four<tag>out=4;</tag></item>
                <item>five<tag>out=5;</tag></item>
                <item>six<tag>out=6;</tag></item>
                <item>seven<tag>out=7;</tag></item>
                <item>eight<tag>out=8;</tag></item>
                <item>nine<tag>out=9;</tag></item>
            </one-of>
        </rule>

        <rule id="teens">
            <one-of>
                <item>ten<tag>out=10;</tag></item>
                <item>eleven<tag>out=11;</tag></item>
                <item>twelve<tag>out=12;</tag></item>
                <item>thirteen<tag>out=13;</tag></item>
                <item>fourteen<tag>out=14;</tag></item>
                <item>fifteen<tag>out=15;</tag></item>
                <item>sixteen<tag>out=16;</tag></item>
                <item>seventeen<tag>out=17;</tag></item>
                <item>eighteen<tag>out=18;</tag></item>
                <item>nineteen<tag>out=19;</tag></item>
                <item>10<tag>out=10;</tag></item>
                <item>11<tag>out=11;</tag></item>
                <item>12<tag>out=12;</tag></item>
                <item>13<tag>out=13;</tag></item>
                <item>14<tag>out=14;</tag></item>
                <item>15<tag>out=15;</tag></item>
                <item>16<tag>out=16;</tag></item>
                <item>17<tag>out=17;</tag></item>
                <item>18<tag>out=18;</tag></item>
                <item>19<tag>out=19;</tag></item>
            </one-of>
        </rule>

        <rule id="above_twenty">
            <one-of>
                <item>twenty<tag>out=20;</tag></item>
                <item>thirty<tag>out=30;</tag></item>
                <item>forty<tag>out=40;</tag></item>
                <item>fifty<tag>out=50;</tag></item>
                <item>sixty<tag>out=60;</tag></item>
                <item>seventy<tag>out=70;</tag></item>
                <item>eighty<tag>out=80;</tag></item>
                <item>ninety<tag>out=90;</tag></item>
                <item>20<tag>out=20;</tag></item>
                <item>30<tag>out=30;</tag></item>
                <item>40<tag>out=40;</tag></item>
                <item>50<tag>out=50;</tag></item>
                <item>60<tag>out=60;</tag></item>
                <item>70<tag>out=70;</tag></item>
                <item>80<tag>out=80;</tag></item>
                <item>90<tag>out=90;</tag></item>
            </one-of>
            <item repeat="0-1"><ruleref uri="#digits"/><tag>out += rules.digits;</tag></item>
        </rule>

</grammar>
```

### 에이전트
<a name="generic-agent"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <rule id="main" scope="public">
             <tag>out=""</tag>
             <ruleref uri="#text"/><tag>out = rules.text</tag>
         </rule>

         <rule id="text">
           <one-of>
              <item>Can I talk to the agent<tag>out="You will be trasnfered to the agent in a while"</tag></item>
              <item>talk to an agent<tag>out="You will be trasnfered to the agent in a while"</tag></item>
           </one-of>
         </rule>
</grammar>
```

### 인사말
<a name="generic-greeting"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <rule id="main" scope="public">
             <tag>out=""</tag>
             <ruleref uri="#text"/><tag>out = rules.text</tag>
         </rule>

         <rule id="text">
           <one-of>
              <item>hey<tag>out="Greeting"</tag></item>
              <item>hi<tag>out="Greeting"</tag></item>
              <item>Hi<tag>out="Greeting"</tag></item>
              <item>Hey<tag>out="Greeting"</tag></item>
              <item>Hello<tag>out="Greeting"</tag></item>
              <item>hello<tag>out="Greeting"</tag></item>
           </one-of>
         </rule>
</grammar>
```

### 망설임
<a name="generic-hesitation"></a>

```
<?xml version="1.0" encoding="UTF-8" ?>
<grammar xmlns="http://www.w3.org/2001/06/grammar"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         xml:lang="en-US" version="1.0"
         root="main"
         mode="voice"
         tag-format="semantics/1.0">

         <rule id="main" scope="public">
             <tag>out=""</tag>
             <ruleref uri="#text"/><tag>out = rules.text</tag>
         </rule>

         <rule id="text">
           <one-of>
              <item>Hmm<tag>out="Waiting for your input"</tag></item>
              <item>Mmm<tag>out="Waiting for your input"</tag></item>
              <item>Can you please wait<tag>out="Waiting for your input"</tag></item>
           </one-of>
         </rule>
</grammar>
```

# 복합 슬롯 유형
<a name="composite-slots"></a>

복합 슬롯은 단일 사용자 입력으로 여러 정보를 캡처하는 둘 이상의 슬롯의 조합입니다. 예를 들어, “도시 및 주 또는 우편번호”를 요청하여 위치를 유도하도록 봇을 구성할 수 있습니다. 반대로, 별도의 슬롯 유형을 사용하도록 대화를 구성하면 대화가 대화 환경이 경직됩니다(“도시는 무엇입니까?” 다음에 “우편번호는 무엇입니까?”라고 질문). 복합 슬롯을 사용하면 단일 슬롯을 통해 모든 정보를 캡처할 수 있습니다. 복합 슬롯은 도시, 주, 우편 번호 등 하위 슬롯이라는 슬롯의 조합입니다.

사용 가능한 Amazon Lex 슬롯 유형(기본 제공)과 자체 슬롯(사용자 지정 슬롯)을 조합하여 사용할 수 있습니다. 필요한 하위 슬롯 내에서 정보를 캡처하는 논리적 표현식을 설계할 수 있습니다. 예: 도시 및 주 또는 우편번호.

복합 슬롯 유형은 en-US에서만 사용할 수 있습니다.

**복합 슬롯 유형 생성**

복합 슬롯 내에서 하위 슬롯을 사용하려면 먼저 복합 슬롯 유형을 구성해야 합니다. 구성하려면 슬롯 유형 추가 콘솔 단계 또는 API 작업을 사용하세요. 복합 슬롯 유형의 이름과 설명을 선택한 후에는 하위 슬롯에 대한 정보를 제공해야 합니다. 슬롯 유형 추가에 대한 자세한 내용은 [슬롯 유형 추가](add-slot-types.md) 단원을 참조하세요.

**하위 슬롯**

복합 슬롯 유형은 하위 슬롯이라고 하는 기본 슬롯을 구성해야 합니다. 한 번의 요청으로 고객으로부터 여러 정보를 얻으려는 경우 하위 슬롯을 조합하여 구성하세요. 예: 도시, 주, 우편번호. 복합 슬롯에는 최대 6개의 하위 슬롯을 추가할 수 있습니다.

단일 슬롯 유형의 슬롯을 사용하여 복합 슬롯 유형에 하위 슬롯을 추가할 수 있습니다. 하지만 복합 슬롯 유형을 하위 슬롯의 슬롯 유형으로 사용할 수는 없습니다.

다음 이미지는 색상, 연료 유형, 제조업체, 모델, VIN 및 연도와 같은 하위 슬롯의 조합인 복합 슬롯 “Car”의 그림입니다.

![\[슬롯 유형 패널에는 하위 슬롯이 표시됩니다.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/cst-slottype.png)


![\[하위 슬롯 패널\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/cst-subslots.png)


**표현식 작성기**

복합 슬롯의 성능을 높이기 위해 표현식 작성기(옵션)를 사용할 수 있습니다. 표현식 작성기를 사용하면 필요한 하위 슬롯 값을 원하는 순서로 캡처하는 논리적 슬롯 표현식을 설계할 수 있습니다. 부울 표현식의 일부로 AND 및 OR과 같은 연산자를 사용할 수 있습니다. 설계된 표현식에 따라 필수 하위 슬롯이 충족되면 복합 슬롯이 채워진 것으로 간주됩니다.

**복합 슬롯 유형 사용**

일부 의도의 경우 여러 슬롯을 단일 슬롯의 일부로 캡처하고 싶을 수 있습니다. 예를 들어 자동차 정비 일정 봇은 의도가 다음과 같을 수 있습니다.

`My car is a {car}`

의도는 \$1car\$1 복합 슬롯에 차량의 세부 정보로 구성된 슬롯 목록이 포함되어 있을 것으로 예상합니다. 예: “2021년식 흰색 토요타 캠리”.

복합 슬롯은 다중 값 슬롯과 다릅니다. 복합 슬롯은 각각 고유한 값을 가진 여러 슬롯으로 구성됩니다. 반면 다중 값 슬롯은 값 목록을 포함할 수 있는 단일 슬롯입니다. 다중 값 슬롯에 대한 자세한 내용은 [슬롯에서 여러 값 사용](multi-valued-slots.md) 단원을 참조하세요.

복합 슬롯의 경우 Amazon Lex는 `RecognizeText` 또는 `RecognizeUtterance` 작업에 대한 응답으로 각 하위 슬롯의 값을 반환합니다. 다음은 발화에 대해 반환되는 슬롯 정보입니다. “CarService 봇에서 ‘2021식 희색 도요타 캠리’의 정비를 예약하고 싶습니다”.

```
"slots": {
    "CarType": {
        "value": {
            "originalValue": "White Toyota Camry 2021",
            "interpretedValue": "White Toyota Camry 2021",
            "resolvedValues": [
                "white Toyota Camry 2021"
            ]
        },
        "subSlots": {
            "Color": {
                "value": {
                    "originalValue": "White",
                    "interpretedValue": "White",
                    "resolvedValues": [
                        "white"
                    ]
                },
                "shape": "Scalar"
            },
            "Manufacturer": {
                "value": {
                    "originalValue": "Toyota",
                    "interpretedValue": "Toyota",
                    "resolvedValues": [
                        "Toyota"
                    ]
                },
                "shape": "Scalar"
            },
            "Model": {
                "value": {
                    "originalValue": "Camry",
                    "interpretedValue": "Camry",
                    "resolvedValues": [
                       "Camry"
                    ]
                },
                "shape": "Scalar"
            },
            "Year": {
                "value": {
                    "originalValue": "2021",
                    "interpretedValue": "2021",
                    "resolvedValues": [
                        "2021"
                    ]
                },
                "shape": "Scalar"
            }
        }
    },
    ...
}
```

대화의 첫 번째 턴이나 n번째 턴에서 복합 슬롯을 유도할 수 있습니다. 제공된 입력 값에 따라 복합 슬롯은 나머지 필수 하위 슬롯을 유도할 수 있습니다.

복합 슬롯은 항상 각 하위 슬롯의 값을 반환합니다. 발화에 특정 하위 슬롯에 대해 인식할 수 있는 값이 포함되어 있지 않으면 해당 하위 슬롯에 대한 응답이 반환되지 않습니다.

복합 슬롯은 텍스트 및 음성 입력 모두에 사용할 수 있습니다.

의도에 슬롯을 추가할 때 복합 슬롯은 사용자 지정 슬롯 유형으로만 사용할 수 있습니다.

프롬프트에서 복합 슬롯을 사용할 수 있습니다. 예를 들어 의도에 대한 확인 프롬프트를 설정할 수 있습니다.

`Would you like me to schedule service for your 2021 White Toyota Camry?`

Amazon Lex는 사용자에게 메시지를 보낼 경우 “2021식 희색 도요타 캠리에 대한 정비를 예약하시겠습니까?”라는 메시지를 보냅니다.

각 하위 슬롯은 슬롯으로 구성됩니다. 슬롯 프롬프트를 추가하여 하위 슬롯과 샘플 발화를 유도할 수 있습니다. 하위 슬롯에 대해 대기 및 계속을 활성화하고 기본값을 설정할 수 있습니다. 자세한 내용은 [Lex V2 봇에서 의도에 기본 슬롯 값 사용](context-mgmt-default.md) 섹션을 참조하세요.

![\[복합 슬롯 설정 패널\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/cst-composite.png)


슬롯 난독화를 사용하여 대화 로그에서 전체 복합 슬롯을 마스킹할 수 있습니다. 슬롯 난독화는 복합 슬롯 수준에서 적용되며, 활성화되면 복합 슬롯에 속하는 하위 슬롯의 값이 난독화된다는 점에 유의하세요. 슬롯 값을 난독화하면 각 슬롯 값의 값이 슬롯의 이름으로 대체됩니다. 자세한 내용은 [Lex V2에서 대화 로그의 슬롯 값 가리기](monitoring-obfuscate.md) 섹션을 참조하세요.

![\[복합 슬롯 정보 패널\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/cst-slotinfo.png)


**복합 슬롯 유형 편집**

복합 슬롯 구성 내에서 하위 슬롯을 편집하여 하위 슬롯 이름 및 슬롯 유형을 수정할 수 있습니다. 하지만 의도가 복합 슬롯을 사용 중인 경우에는 하위 슬롯을 수정하기 전에 의도를 편집해야 합니다.

![\[기존 의도에 대한 경고 패널\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/cst-alert.png)


**복합 슬롯 유형 삭제**

복합 슬롯 구성 내에서 하위 슬롯을 삭제할 수 있습니다. 의도 내에서 하위 슬롯을 사용 중인 경우 해당 하위 슬롯은 여전히 해당 의도에서 제거된다는 점에 유의하세요.

![\[하위 슬롯으로 의도 삭제\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/cst-delete.png)


표현식 작성기의 슬롯 표현식은 삭제된 하위 슬롯에 대한 알림을 제공합니다.

![\[기존 의도에 대한 슬롯 유형\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/cst-slottype.png)


# 콘솔을 사용한 봇 테스트
<a name="test-bot"></a>

Amazon Lex V2 콘솔에는 봇과의 상호 작용을 테스트하는 데 사용할 수 있는 테스트 창이 있습니다. 테스트 창을 사용하여 봇과 테스트 대화를 나누고 애플리케이션이 봇으로부터 받는 응답을 확인할 수 있습니다.

봇을 사용하여 수행할 수 있는 테스트 유형은 다음과 같이 2가지입니다. 첫 번째인 익스프레스 테스트에서는 봇을 만들 때 사용한 것과 똑같은 문구로 봇을 테스트할 수 있습니다. 예를 들어 의도에 “꽃을 픽업하고 싶어요”라는 말을 추가한 경우 해당 문구를 정확히 사용하여 봇을 테스트할 수 있습니다.

두 번째 유형인 전체 테스트에서는 구성한 발화와 관련된 문구를 사용하여 봇을 테스트할 수 있습니다. 예를 들어, “꽃을 주문할 수 있나요?”라는 문구를 사용하여 봇과 대화를 시작할 수 있습니다.

특정 별칭과 언어를 사용하여 봇을 테스트합니다. 봇의 개발 버전을 테스트하는 경우 `TestBotAlias` 별칭을 테스트용으로 사용합니다.

**테스트 창을 열려면**

1. AWS Management Console에 로그인하여 [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)에서 Amazon Lex 콘솔을 엽니다.

1. 봇 목록에서 테스트할 봇을 선택합니다.

1. 왼쪽 메뉴에서 **별칭**을 선택합니다.

1. 별칭 목록에서 테스트할 별칭을 선택합니다.

1. **언어**에서 테스트할 언어의 라디오 버튼을 선택한 다음 **테스트**를 선택합니다.

**테스트**를 선택하면 콘솔에서 테스트 창이 열립니다. 테스트 창을 사용하여 다음 그림과 같이 봇과 상호 작용할 수 있습니다.

![\[꽃 주문 봇과의 대화를 보여주는 테스트 창입니다.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/test-example-1.png)


대화 외에도 테스트 창에서 **검사**를 선택하여 봇에서 반환된 응답을 확인할 수 있습니다. 첫 번째 화면에는 봇에서 테스트 창으로 반환된 정보의 요약이 표시됩니다.

![\[봇과의 대화에 대한 요약 보기를 보여주는 테스트 창입니다.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/test-example-2.png)


또한 테스트 검사 창을 사용하여 봇과 테스트 창 간에 전송되는 JSON 구조를 확인할 수 있습니다. 테스트 창의 요청과 Amazon Lex V2의 응답을 모두 볼 수 있습니다.

![\[봇과의 대화에 사용된 JSON 구조를 보여주는 테스트 창입니다.\]](http://docs.aws.amazon.com/ko_kr/lexv2/latest/dg/images/test-example-3.png)
