

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Bekerja dengan bot Amazon Lex V2
<a name="building-bots"></a>

Anda membuat bot Amazon Lex V2 untuk berinteraksi dengan pengguna Anda untuk memperoleh informasi guna menyelesaikan tugas. Misalnya, Anda dapat membuat bot yang mengumpulkan informasi yang diperlukan untuk memesan karangan bunga atau memesan kamar hotel.

Untuk membangun bot, Anda memerlukan informasi berikut:

1. Bahasa yang digunakan bot untuk berinteraksi dengan pelanggan. Anda dapat memilih satu atau lebih bahasa, setiap bahasa berisi maksud independen, slot, dan jenis slot.

1. Maksud, atau tujuan, yang bot membantu pengguna memenuhi. Bot dapat berisi satu atau lebih maksud, seperti memesan bunga, atau memesan hotel dan mobil sewaan. Anda perlu memutuskan pernyataan, atau ucapan, yang dibuat pengguna untuk memulai maksud.

1. Informasi, atau slot, yang perlu Anda kumpulkan dari pengguna untuk memenuhi niat. Misalnya, Anda mungkin perlu mendapatkan jenis bunga dari pengguna atau tanggal mulai reservasi hotel. Anda perlu menentukan satu atau lebih petunjuk yang digunakan Amazon Lex V2 untuk mendapatkan nilai slot dari pengguna.

1. Jenis slot yang Anda butuhkan dari pengguna. Anda mungkin perlu membuat jenis slot khusus, seperti daftar bunga yang dapat dipesan pengguna, atau Anda dapat menggunakan jenis slot bawaan, seperti menggunakan jenis `AMAZON.Date` slot untuk tanggal mulai reservasi.

1. Interaksi pengguna mengalir di dalam dan di antara maksud. Anda dapat mengonfigurasi alur percakapan untuk menentukan interaksi antara pengguna dan bot setelah intent dipanggil. Anda dapat membuat fungsi Lambda untuk memvalidasi dan memenuhi intent.

**Topics**
+ [Perubahan alur percakapan di Amazon Lex V2](understanding-new-flows.md)
+ [Berbagai cara untuk membuat bot dengan Amazon Lex V2](create-bot.md)
+ [Menambahkan bahasa baru ke bot Amazon Lex V2](add-language.md)
+ [Menambahkan maksud](add-intents.md)
+ [Menambahkan jenis slot](add-slot-types.md)
+ [Menguji bot menggunakan konsol](test-bot.md)

**catatan**  
Pada 17 Agustus 2022, Amazon Lex V2 merilis perubahan pada cara percakapan dikelola dengan pengguna. Perubahan ini memberi Anda kontrol lebih besar atas jalur yang diambil pengguna melalui percakapan. Untuk informasi selengkapnya, lihat [Perubahan alur percakapan di Amazon Lex V2](understanding-new-flows.md). Bot yang dibuat sebelum 17 Agustus 2022 tidak mendukung pesan kait kode dialog, menyetel nilai, mengonfigurasi langkah selanjutnya, dan menambahkan kondisi.

# Perubahan alur percakapan di Amazon Lex V2
<a name="understanding-new-flows"></a>

Pada 17 Agustus 2022 Amazon Lex V2 merilis perubahan pada cara percakapan dikelola dengan pengguna. Perubahan ini memberi Anda kontrol lebih besar atas jalur yang diambil pengguna melalui percakapan. 

Sebelum perubahan, Amazon Lex V2 mengelola percakapan dengan memunculkan slot berdasarkan prioritas mereka dalam niat. Anda dapat mengubah perilaku ini secara dinamis dan mengubah jalur percakapan berdasarkan input pengguna dengan menggunakan fungsi DialogAction Lambda. Ini dapat dilakukan dengan melacak keadaan percakapan saat ini dan secara terprogram memutuskan apa yang harus dilakukan selanjutnya berdasarkan status sesi. 

Dengan perubahan ini, Anda dapat membuat jalur percakapan dan cabang bersyarat menggunakan konsol Amazon Lex V2 atau APIs tanpa menggunakan fungsi Lambda. Amazon Lex V2 melacak status percakapan dan mengontrol apa yang harus dilakukan selanjutnya berdasarkan kondisi yang ditentukan saat bot dibuat. Ini memungkinkan Anda untuk dengan mudah membuat percakapan yang kompleks saat merancang bot Anda.

Perubahan ini memberi Anda kendali penuh atas percakapan dengan pelanggan Anda. Namun, Anda tidak diharuskan untuk menentukan jalur. Jika Anda tidak menentukan jalur percakapan, Amazon Lex V2 akan membuat jalur default berdasarkan prioritas slot dalam maksud Anda. Anda dapat terus menggunakan fungsi Lambda untuk menentukan jalur percakapan secara dinamis. Dalam skenario seperti itu, percakapan dilanjutkan berdasarkan status sesi yang dikonfigurasi dalam fungsi Lambda.

Pembaruan ini memberikan yang berikut:
+ Pengalaman konsol baru untuk membuat bot dengan alur percakapan yang kompleks.
+ Pembaruan yang ada APIs untuk membuat bot untuk mendukung alur percakapan baru.
+ Respons awal untuk mengirim pesan pada pemanggilan maksud.
+ Tanggapan baru untuk elisitasi slot, pemanggilan Lambda sebagai pengait kode dialog dan konfirmasi.
+ Kemampuan untuk menentukan langkah selanjutnya di setiap giliran percakapan.
+ Evaluasi kondisi untuk merancang beberapa jalur percakapan.
+ Pengaturan nilai slot dan atribut sesi kapan saja selama percakapan.

Perhatikan hal berikut untuk bot lama:
+ Bot yang dibuat sebelum 17 Agustus 2022 terus menggunakan mekanisme lama untuk mengelola arus percakapan. Bot yang dibuat setelah tanggal tersebut menggunakan cara baru manajemen alur percakapan. 
+ Bot baru yang dibuat melalui impor setelah 17 Agustus 2022 menggunakan manajemen alur percakapan baru. Impor pada bot yang ada terus menggunakan cara lama manajemen percakapan.
+ Untuk mengaktifkan manajemen alur percakapan baru untuk bot yang dibuat sebelum 17 Agustus 2022, ekspor bot, lalu impor bot menggunakan nama bot baru. Bot yang baru dibuat dari impor menggunakan manajemen alur percakapan baru.

Perhatikan hal berikut untuk bot baru yang dibuat setelah 17 Agustus 2022:
+ Amazon Lex V2 mengikuti alur percakapan yang ditentukan persis seperti yang dirancang untuk memberikan pengalaman yang diinginkan. Anda harus mengonfigurasi semua cabang alur untuk menghindari jalur percakapan default selama runtime.
+ Langkah-langkah percakapan mengikuti hook kode harus sepenuhnya dikonfigurasi, karena langkah-langkah yang tidak lengkap dapat menyebabkan kegagalan bot. Kami menyarankan Anda memvalidasi bot yang dibuat sebelum 17 Agustus 2022, karena untuk bot ini, tidak ada validasi otomatis langkah-langkah percakapan mengikuti kait kode.

# Berbagai cara untuk membuat bot dengan Amazon Lex V2
<a name="create-bot"></a>

Anda dapat membuat bot dengan Amazon Lex V2 dengan cara berikut:

1. Gunakan konsol Amazon Lex V2 untuk membuat bot menggunakan antarmuka situs web. Untuk informasi selengkapnya, lihat [Membuat bot menggunakan konsol Amazon Lex V2](create-bot-console.md).

1. Gunakan Descriptive Bot Builder untuk membuat bot menggunakan kemampuan AI generatif Amazon Bedrock. Untuk informasi selengkapnya, lihat [Gunakan deskripsi untuk membangun bot di Lex V2 dengan pembuat bot deskriptif](nld-bots.md).

1. Gunakan templat bot untuk membuat bot yang telah dikonfigurasi sebelumnya yang cocok dengan kasus penggunaan bisnis umum. Untuk informasi selengkapnya, lihat [Membuat bot Amazon Lex V2 menggunakan template](bot-templates.md).

1. Gunakan [AWS SDK](https://aws.amazon.com/tools/#sdk) untuk membuat bot menggunakan operasi API.

1. Gunakan perancang Chatbot Otomatis untuk membuat bot menggunakan transkrip obrolan yang ada antara agen dan pelanggan. Untuk informasi selengkapnya, lihat [Membuat bot Amazon Lex V2 menggunakan Desainer Chatbot Otomatis](designing.md).

1. Impor definisi bot yang ada. Untuk informasi selengkapnya, lihat [Mengimpor bot di Lex V2](import.md).

1. Gunakan CloudFormation untuk membuat bot. Lihat informasi yang lebih lengkap di [Membuat sumber daya Amazon Lex V2 dengan AWS CloudFormation](creating-resources-with-cloudformation.md).

**Topics**
+ [Membuat bot menggunakan konsol Amazon Lex V2](create-bot-console.md)
+ [Membuat bot Amazon Lex V2 menggunakan template](bot-templates.md)
+ [Membuat bot Amazon Lex V2 menggunakan Desainer Chatbot Otomatis](designing.md)

# Membuat bot menggunakan konsol Amazon Lex V2
<a name="create-bot-console"></a>

Anda membuat bot Amazon Lex V2 untuk berinteraksi dengan pengguna Anda untuk memperoleh informasi guna menyelesaikan tugas. Misalnya, Anda dapat membuat bot yang mengumpulkan informasi yang diperlukan untuk memesan bunga atau memesan kamar hotel. Untuk membuat bot menggunakan AWS Console, mulailah dengan menentukan nama, deskripsi, dan beberapa informasi dasar.

1. Masuk ke AWS Management Console dan buka konsol Amazon Lex di [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).

1. Pilih **Buat bot**.

1. Di bagian **Metode pembuatan**, pilih **Tradisional** dan kemudian pilih **Buat bot kosong**.

1. Di bagian **konfigurasi Bot**, beri bot nama dan deskripsi opsional.

1. Di bagian **izin IAM**, pilih peran AWS Identity and Access Management (IAM) yang memberikan izin Amazon Lex V2 untuk mengakses layanan AWS lainnya, seperti Amazon. CloudWatch Anda dapat meminta Amazon Lex V2 membuat peran, atau Anda dapat memilih peran yang ada dengan CloudWatch izin. 

1. Di bagian **Children's Online Privacy Protection Act (COPPA)**, pilih respons yang sesuai.

1. Di bagian **batas waktu sesi Idle**, pilih durasi yang Amazon Lex V2 menyimpan sesi dengan pengguna terbuka. Amazon Lex V2 mempertahankan variabel sesi selama sesi sehingga bot Anda dapat melanjutkan percakapan dengan variabel yang sama.

1. Di bagian **Pengaturan lanjutan** (opsional), tambahkan tag yang membantu mengidentifikasi bot, mengontrol akses, dan memantau sumber daya.

1. Pilih **Berikutnya** untuk membuat bot dan pindah ke menambahkan bahasa.

# Membuat bot Amazon Lex V2 menggunakan template
<a name="bot-templates"></a>

Amazon Lex V2 menawarkan solusi pra-bangun untuk menciptakan pengalaman dalam skala besar dan mendorong keterlibatan digital. Templat bot pra-bangun mengotomatiskan dan menstandarisasi pengalaman klien. Templat bot menyediakan alur ready-to-use percakapan bersama dengan data pelatihan dan permintaan dialog, untuk modalitas suara dan obrolan. Anda dapat mempercepat pengiriman solusi bot sambil mengoptimalkan sumber daya, sehingga Anda dapat fokus pada hubungan pelanggan.

Anda dapat membuat bot bawaan berdasarkan kasus penggunaan bisnis Anda. Anda dapat menggunakan CloudFormation konsol untuk memilih opsi pra-bangun untuk layanan terkait, seperti Amazon S3, Amazon Connect, dan DynamoDB.

Saat ini, Amazon Lex V2 mendukung vertikal bisnis berikut:
+ Jasa keuangan
+ Pesanan eceran
+ Asuransi mobil
+ Telekomunikasi
+ Layanan penerbangan
+ Template tambahan akan tersedia di masa depan.

Anda dapat membuat bot dengan template solusi bisnis yang disediakan, dan menyesuaikannya dengan kebutuhan bisnis Anda.

**catatan**  
Template membuat sumber daya di luar Amazon Lex V2 melalui CloudFormation tumpukan. Tumpukan mungkin perlu dimodifikasi di konsol lain seperti Lambda dan DynamoDB.

**Prasyarat untuk membangun dan menerapkan template bot:**
+ Akun AWS
+ Akses ke layanan AWS berikut:
  + Amazon Lex V2 untuk membuat bot
  + Lambda untuk fungsi login bisnis
  + DynamoDB untuk membuat tabel
  + Akses IAM untuk membuat kebijakan dan peran
  + AWS CloudFormation untuk menjalankan tumpukan
+ Akses IAM dan kredensi kunci rahasia
+ Instans Amazon Connect (opsional)

**catatan**  
Penggunaan layanan AWS yang berbeda menimbulkan biaya penggunaan masing-masing untuk setiap layanan.

**Untuk membuat bot dari template Amazon Lex V2:**

1. Masuk ke AWS Management Console dan buka konsol Amazon Lex di [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).

1. Pilih **template Bot** dari panel navigasi kiri.

1. Pilih vertikal bisnis mana yang ingin Anda gunakan untuk templat bot Anda. CATATAN: Ada 5 templat bot yang tersedia saat ini. Lebih banyak yang akan segera datang.

1. Pilih **Buat** untuk template yang ingin Anda gunakan. Tab terbuka di CloudFormation mana Anda dapat mengedit parameter untuk CloudFormation tumpukan. Semua opsi sudah selesai untuk template yang telah Anda pilih. Anda juga dapat mempelajari lebih lanjut tentang cara kerja templat bot dengan memilih **Pelajari lebih lanjut**.

1. Di CloudFormation konsol, CloudFormation buat konfigurasi default untuk setiap nilai untuk templat yang telah Anda pilih. Anda juga dapat memilih nama tumpukan Anda sendiri, CloudFormation parameter, tabel Amazon DynamoDB, dan parameter Amazon Connect (opsional). 

1. Di bagian bawah jendela, pilih **Buat tumpukan**.

1. CloudFormationmemproses permintaan di latar belakang selama beberapa menit untuk mengonfigurasi bot baru Anda. CATATAN: Proses secara otomatis membuat resource untuk tabel DynamoDB, alur kontak Amazon Connect, dan instans Amazon Connect. Anda dapat melacak kemajuan di CloudFormation konsol, lalu menavigasi kembali ke konsol Amazon Lex V2 setelah pembuatan CloudFormation tumpukan selesai.

1. Jika berhasil dibangun, sebuah pesan muncul dan Anda dapat memilih **Pergi ke daftar bot** untuk pergi ke halaman **Bots**, di mana Anda menemukan bot baru Anda yang siap untuk pengujian dan penggunaan Anda. 

**Mengkonfigurasi templat bot Anda**

**Fungsi Lambda** - Templat bot secara otomatis membuat fungsi Lambda yang diperlukan untuk penerapan Anda. Jika beberapa bot adalah bagian dari solusi template, maka beberapa fungsi Lambda tercantum dalam CloudFormation parameter. Jika Anda memiliki fungsi Lambda yang ada untuk digunakan dengan bot Anda, Anda dapat memasukkan nama fungsi Lambda khusus Anda.

**Amazon DynamoDB** - Templat bot secara otomatis membuat tabel DynamoDB yang diperlukan untuk memuat data kebijakan sampel Anda. Anda juga dapat memasukkan nama tabel DynamoDB kustom Anda. Tabel DynamoDB kustom Anda harus diformat dengan cara yang sama seperti tabel default yang dibuat oleh penerapan templat bot.

**Amazon Connect** - Anda dapat mengonfigurasi instans Amazon Connect agar berfungsi dengan templat bot baru Anda dengan memasukkan ConnectInstance ARN dan yang unik. ContactFlowName Dengan menggunakan Amazon Connect, Anda dapat menguji bot Anda menggunakan sistem IVR dari end-to-end.

**Memecahkan masalah template bot Anda**
+ Periksa apakah Anda memiliki izin yang tepat untuk membuat template yang Anda pilih. Pengguna memerlukan CloudFormation: CreateStack izin bersama dengan izin untuk sumber daya AWS yang tercantum dalam template. Daftar sumber daya yang memerlukan izin pengguna ada di bagian bawah halaman **Buat template**.
+ Jika template bot Anda gagal dibuat, spanduk merah di dalam konsol Amazon Lex V2 menyediakan tautan ke CloudFormation tumpukan yang bertanggung jawab untuk membuat templat. Di dalam CloudFormation konsol, Anda dapat melihat tab peristiwa untuk melihat kesalahan spesifik yang menyebabkan template gagal. Setelah Anda meninjau CloudFormation kesalahan, lihat [Pemecahan Masalah CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/troubleshooting.html) untuk informasi selengkapnya.
+ Templat bot hanya berfungsi dengan data sampel. Anda harus mengisi tabel DynamoDB dengan data Anda untuk membuat template bekerja dengan data kustom Anda.

# Membuat bot Amazon Lex V2 menggunakan Desainer Chatbot Otomatis
<a name="designing"></a>

Perancang Chatbot Otomatis membantu Anda mendesain bot dari transkrip percakapan yang ada. Ini menganalisis transkrip dan menyarankan desain awal dengan maksud dan jenis slot. Anda dapat mengulangi desain bot, menambahkan prompt, membangun, menguji, dan menyebarkan bot.

Setelah Anda membuat bot baru atau menambahkan bahasa ke bot Anda menggunakan konsol atau API Amazon Lex V2, Anda dapat mengunggah transkrip percakapan antara dua pihak. Perancang chatbot otomatis menganalisis transkrip dan menentukan maksud dan jenis slot untuk bot. Ini juga memberi label percakapan yang memengaruhi pembuatan maksud atau jenis slot tertentu untuk ulasan Anda. 

Anda menggunakan konsol Amazon Lex V2 atau API untuk menganalisis transkrip percakapan dan menyarankan maksud dan jenis slot untuk bot.

**catatan**  
Anda hanya dapat menggunakan transkrip dalam bahasa Inggris (AS).

Anda dapat meninjau maksud dan jenis slot yang disarankan setelah perancang chatbot menyelesaikan analisis. Setelah menambahkan maksud atau jenis slot yang disarankan, Anda dapat memodifikasinya atau menghapusnya dari desain bot menggunakan konsol atau API. 

Perancang chatbot otomatis mendukung file transkrip percakapan menggunakan skema Contact Lens for Amazon Connect. Jika Anda menggunakan aplikasi pusat kontak yang berbeda, Anda harus mengubah transkrip percakapan ke format yang digunakan oleh desainer chatbot. Untuk informasi, lihat [Format transkrip masukan](designing-input-format.md).

Untuk menggunakan desainer chatbot otomatis, Anda harus mengizinkan peran IAM yang menjalankan akses desainer. Untuk kebijakan IAM tertentu, lihat[Memungkinkan pengguna untuk menggunakan Desainer Chatbot Otomatis](security_iam_id-based-policy-examples.md#security_iam-bot-designer). Untuk mengaktifkan Amazon Lex V2 mengenkripsi data keluaran dengan AWS KMS kunci opsional, Anda perlu memperbarui kunci dengan kebijakan yang ditampilkan di[Izinkan pengguna menggunakan AWS KMS kunci untuk mengenkripsi dan mendekripsi file](security_iam_id-based-policy-examples.md#security_iam-bot-key).

**catatan**  
Jika Anda menggunakan a KMS key, Anda harus memberikan **KMS key kebijakan**, terlepas dari IAM peran yang digunakan.

**Topics**
+ [Mengimpor transkrip percakapan](designing-import.md)
+ [Membuat maksud dan jenis slot](designing-create.md)
+ [Format transkrip masukan](designing-input-format.md)
+ [Format transkrip keluaran](designing-output-format.md)

# Mengimpor transkrip percakapan
<a name="designing-import"></a>

Mengimpor transkrip percakapan adalah proses tiga langkah: 

1. Siapkan transkrip untuk diimpor dengan mengonversinya ke format yang benar. Jika Anda menggunakan Contact Lens untuk Amazon Connect, transkrip sudah dalam format yang benar. 

1. Unggah transkrip ke bucket Amazon S3. Jika Anda menggunakan Lensa Kontak, transkrip Anda sudah ada di bucket S3.

1. Analisis transkrip menggunakan konsol Amazon Lex V2 atau operasi API. Waktu yang diperlukan untuk menyelesaikan pelatihan tergantung pada volume transkrip dan kompleksitas percakapan. Biasanya, 500 baris transkrip dianalisis setiap menit.

Masing-masing langkah ini dijelaskan di bagian berikut.

## Mengimpor transkrip dari Contact Lens untuk Amazon Connect
<a name="import-connect"></a>

Perancang chatbot otomatis Amazon Lex V2 kompatibel dengan file transkrip Lensa Kontak. Untuk menggunakan file transkrip Lensa Kontak, Anda harus mengaktifkan Lensa Kontak dan mencatat lokasi file outputnya. 

**Untuk mengekspor transkrip dari Lensa Kontak**

1. Aktifkan Lensa Kontak di instans Amazon Connect Anda. Untuk petunjuk, lihat [Mengaktifkan Lensa Kontak untuk Amazon Connect](https://docs.aws.amazon.com/connect/latest/adminguide/enable-analytics.html) di *panduan administrator Amazon Connect*.

1. Perhatikan lokasi bucket S3 yang digunakan Amazon Connect untuk instans Anda. Untuk melihat lokasi, buka halaman **Penyimpanan data** di konsol Amazon Connect. Untuk petunjuknya, lihat [Memperbarui setelan instans](https://docs.aws.amazon.com/connect/latest/adminguide/update-instance-settings.html) di *panduan administrator Amazon Connect*.

Setelah Anda mengaktifkan Lensa Kontak dan mencatat lokasi file transkrip Anda, buka petunjuk [Analisis transkrip Anda menggunakan konsol Amazon Lex V2](#import-import) untuk mengimpor dan menganalisis transkrip Anda.

## Siapkan transkrip
<a name="import-prepare"></a>

Siapkan transkrip Anda dengan membuat file transkrip. 
+ Buat satu file transkrip per percakapan yang mencantumkan interaksi antara para pihak. Setiap interaksi dalam percakapan dapat menjangkau beberapa baris. Anda dapat memberikan versi percakapan yang disunting dan tidak disunting.
+ File harus dalam format JSON yang ditentukan dalam[Format transkrip masukan](designing-input-format.md).
+ Anda harus memberikan setidaknya 1.000 giliran percakapan. Untuk meningkatkan penemuan maksud dan jenis slot Anda, Anda harus memberikan sekitar 10.000 atau lebih giliran percakapan. Perancang chatbot otomatis hanya akan memproses 700.000 putaran pertama. 
+ Tidak ada batasan jumlah file transkrip yang dapat Anda unggah, juga tidak ada batasan ukuran file.

Jika Anda berencana untuk memfilter transkrip yang Anda impor berdasarkan tanggal, file harus dalam struktur direktori berikut:

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

 File transkrip harus berisi tanggal dalam format "yyyy-mm-dd" di suatu tempat di nama file. 

**Untuk mengekspor transkrip dari aplikasi pusat kontak lainnya**

1. Gunakan alat aplikasi pusat kontak Anda untuk mengekspor percakapan. Percakapan harus berisi setidaknya informasi yang ditentukan dalam[Format transkrip masukan](designing-input-format.md).

1. Ubah transkrip yang dihasilkan oleh aplikasi pusat kontak Anda ke format yang dijelaskan dalam[Format transkrip masukan](designing-input-format.md). Anda bertanggung jawab untuk melakukan transformasi.

Kami menyediakan tiga skrip untuk menyiapkan transkrip. File tersebut adalah:
+ Skrip untuk menggabungkan transkrip Lensa Kontak dengan log percakapan Amazon Lex V2. Transkrip Lensa Kontak tidak menyertakan bagian dari percakapan Amazon Connect yang berinteraksi dengan bot Amazon Lex V2. Skrip ini mengharuskan log percakapan diaktifkan untuk Amazon Lex V2, dan izin yang sesuai untuk menanyakan CloudWatch log percakapan Log dan bucket S3 Lensa Kontak.
+ Skrip untuk mengubah analitik panggilan Amazon Transcribe ke format input Amazon Lex V2.
+ Skrip untuk mengubah transkrip obrolan Amazon Connect ke format input Amazon Lex V2.

[Anda dapat mengunduh skrip dari GitHub repositori ini: -integration. https://github.com/aws-samples/ amazon-lex-bot-recommendation](https://github.com/aws-samples/amazon-lex-bot-recommendation-integration)

## Unggah transkrip Anda ke bucket S3
<a name="import-upload"></a>

Jika Anda menggunakan Contact Lens, file transkrip Anda sudah terkandung dalam bucket S3. Untuk lokasi dan nama file file transkrip Anda, lihat [Contoh file keluaran Lensa Kontak](https://docs.aws.amazon.com/connect/latest/adminguide/contact-lens-example-output-files.html) di *panduan administrator Amazon Connect*.

Jika Anda menggunakan aplikasi pusat kontak lain dan Anda belum menyiapkan bucket S3 untuk file transkrip Anda, ikuti prosedur ini. Jika tidak, jika Anda memiliki bucket S3 yang sudah ada, setelah masuk ke konsol Amazon S3, ikuti prosedur ini yang dimulai dengan langkah 5.

**Untuk mengunggah file ke bucket S3**

1. Masuk ke AWS Management Console dan buka konsol Amazon S3 di. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

1. Pilih **Buat bucket**.

1. Beri nama bucket dan pilih Region. Wilayah harus sama dengan yang Anda gunakan untuk Amazon Lex V2. Tetapkan opsi lain sesuai kebutuhan untuk kasus penggunaan Anda.

1. Pilih **Buat bucket**.

1. Dari daftar bucket, pilih bucket yang sudah ada atau bucket yang baru saja Anda buat

1. Pilih **Unggah**.

1. Tambahkan file transkrip yang ingin Anda unggah.

1. Pilih **Unggah**.

## Analisis transkrip Anda menggunakan konsol Amazon Lex V2
<a name="import-import"></a>

Anda hanya dapat menggunakan desain bot otomatis dalam bahasa kosong. Anda dapat menambahkan bahasa baru ke bot yang ada, atau membuat bot baru. 

**Untuk membuat bahasa baru di bot baru**

1. Masuk ke AWS Management Console dan buka konsol Amazon Lex di [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).

1. Pilih **Buat bot**

1. Pilih **Mulai dengan Desainer Chatbot Otomatis**. Isi informasi untuk membuat bot baru Anda.

1. Pilih **Berikutnya**

1. Dalam **Tambahkan bahasa ke bot**, isi informasi untuk bahasa tersebut.

1. Di **lokasi file Transkrip di bagian S3**, pilih bucket S3 yang berisi file transkrip Anda dan jalur lokal ke file jika perlu.

1. Anda dapat memilih yang berikut ini secara opsional:
   +  AWS KMS Kunci untuk mengenkripsi data transkrip selama pemrosesan. Jika Anda tidak memilih kunci, AWS KMS kunci layanan digunakan.
   + Untuk memfilter transkrip ke rentang tanggal tertentu. Jika Anda memilih untuk memfilter transkrip, transkrip harus berada dalam struktur folder yang benar. Untuk informasi selengkapnya, lihat [Siapkan transkrip](#import-prepare).

1. Pilih **Selesai**.

Tunggu Amazon Lex V2 memproses transkrip. Anda melihat pesan penyelesaian saat analisis selesai.

**Cara berhenti menganalisis transkrip Anda**

Jika Anda perlu menghentikan analisis transkrip yang telah Anda unggah, Anda dapat menghentikan `BotRecommendation` pekerjaan yang sedang berjalan, yang `BotRecommendationStatus` berstatus sebagai pemrosesan. Anda dapat mengklik tombol **Stop processing** yang ada di banner setelah mengirimkan pekerjaan dari konsol atau dengan menggunakan CLI SDK untuk API. `StopBotRecommendation` Untuk informasi selengkapnya, lihat [StopBotRecommendation](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_StopBotRecommendation.html)

Setelah memanggil`StopBotRecommendation`, internal `BotRecommendationStatus` diatur ke `Stopping` dan Anda tidak dikenakan biaya. Untuk memastikan pekerjaan telah berhenti, Anda dapat memanggil `DescribeBotRecommendation` API dan memverifikasi bahwa `BotRecommendationStatus` itu`Stopped`. Ini biasanya memakan waktu 3-4 menit.

Anda tidak dikenakan biaya untuk pemrosesan setelah `StopBotRecommendation` API dipanggil.

# Membuat maksud dan jenis slot
<a name="designing-create"></a>

Setelah perancang chatbot membuat maksud dan jenis slot, Anda memilih maksud dan jenis slot untuk ditambahkan ke bot Anda. Anda dapat meninjau detail setiap maksud dan jenis slot untuk membantu Anda memutuskan rekomendasi mana yang paling relevan dengan kasus penggunaan Anda.

Anda dapat mengklik nama maksud yang disarankan untuk melihat contoh ucapan dan slot yang disarankan oleh perancang chatbot. Jika memilih **Tampilkan transkrip terkait**, Anda juga dapat menggulir percakapan yang Anda berikan. Transkrip ini memengaruhi rekomendasi perancang chatbot tentang maksud ini. Jika Anda mengklik contoh ucapan, Anda dapat meninjau percakapan utama dan pergantian dialog yang relevan, yang memengaruhi ucapan tertentu tersebut.

Anda dapat mengklik nama jenis slot tertentu untuk melihat nilai slot yang telah direkomendasikan. Jika Anda memilih **Tampilkan transkrip terkait**, Anda dapat meninjau percakapan yang memengaruhi jenis slot ini, dengan prompt agen yang memunculkan jenis slot yang disorot. Jika Anda mengklik nilai jenis slot tertentu, Anda dapat meninjau percakapan utama dan pergantian dialog yang relevan yang memengaruhi nilai ini.

**Untuk meninjau dan menambahkan maksud dan jenis slot**

1. Masuk ke AWS Management Console dan buka konsol Amazon Lex di [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).

1. Dari daftar bot, pilih bot yang ingin Anda gunakan.

1. Pilih **Lihat bahasa**.

1. Dari daftar bahasa, pilih bahasa yang akan digunakan.

1. Dalam **struktur Percakapan**, pilih **Tinjau**.

1. Dalam daftar maksud dan jenis slot, pilih yang akan ditambahkan ke bot. Anda dapat memilih jenis maksud atau slot untuk melihat detail dan transkrip terkait.

Maksud diurutkan berdasarkan keyakinan yang dimiliki Amazon Lex V2 bahwa maksud tersebut terkait dengan transkrip yang diproses.

# Format transkrip masukan
<a name="designing-input-format"></a>

Berikut ini adalah format file input untuk menghasilkan maksud dan jenis slot untuk bot Anda. File input harus berisi bidang-bidang ini. Bidang lain diabaikan. 

Format input kompatibel dengan format output dari Contact Lens untuk Amazon Connect. Jika Anda menggunakan Lensa Kontak, Anda tidak perlu memodifikasi file transkrip Anda. Untuk informasi selengkapnya, lihat [Contoh file keluaran Lensa Kontak](https://docs.aws.amazon.com/connect/latest/adminguide/contact-lens-example-output-files.html). Jika Anda menggunakan aplikasi pusat kontak lain, Anda harus mengubah file transkrip Anda ke format ini. 

```
{
    "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"
        }
    ]
}
```

Bidang berikut harus ada dalam file input:
+ **Peserta** mengidentifikasi peserta dalam percakapan dan peran yang mereka mainkan.
+ **Versi** Versi format file input. Selalu “1.1.0".
+ **ContentMetadata**Menunjukkan apakah Anda menghapus informasi sensitif dari transkrip. Setel `Output` bidang ke “Mentah” jika transkrip berisi informasi sensitif.
+ **CustomerMetadata**Pengenal unik untuk percakapan.
+ **Transkrip** Teks percakapan antara pihak-pihak dalam percakapan. Setiap giliran percakapan diidentifikasi dengan pengenal unik.

# Format transkrip keluaran
<a name="designing-output-format"></a>

Format transkrip keluaran hampir sama dengan format transkrip input. Namun itu juga mencakup beberapa metadata pelanggan dan segmen daftar bidang yang memengaruhi saran maksud dan jenis slot. Anda dapat mengunduh transkrip keluaran dari halaman **Tinjauan** di konsol atau menggunakan Amazon Lex V2 API. Untuk informasi selengkapnya, lihat [Format transkrip masukan](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**— Ada dua bidang yang ditambahkan ke `CustomerMetadata` bidang, nama file input yang berisi percakapan dan format input, yang selalu “Lex”.
+ **InfluencingSegments**— Mengidentifikasi segmen percakapan yang memengaruhi saran dari maksud atau jenis slot. ID dari maksud atau jenis slot mengidentifikasi yang spesifik yang dipengaruhi oleh percakapan.

# Menambahkan bahasa baru ke bot Amazon Lex V2
<a name="add-language"></a>

Anda menambahkan satu atau beberapa bahasa dan lokal ke bot Anda untuk memungkinkannya berkomunikasi dengan pengguna dalam bahasa mereka. Anda menentukan maksud, slot, dan jenis slot secara terpisah untuk setiap bahasa sehingga ucapan, petunjuk, dan nilai slot khusus untuk bahasa tersebut.

Bot Anda harus berisi setidaknya satu bahasa.

**Untuk menambahkan bahasa ke bot Anda**

1. Masuk ke AWS Management Console dan buka konsol Amazon Lex di [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).

1. Di bagian **Bots**, pilih bot yang ingin Anda tambahkan bahasa.

1. Di bagian **Tambahkan bahasa**, klik **Lihat bahasa**.

1. Di bagian **Semua bahasa**, klik **Tambahkan bahasa**.

1. Di bagian **Tambahkan bahasa baru**, pilih **Tambahkan bahasa dari awal**.

1. Di bagian **Detail bahasa**, pilih bahasa yang ingin Anda tambahkan.

1. Jika bot Anda mendukung interaksi suara, di bagian **Suara**, pilih suara Amazon Polly yang digunakan Amazon Lex V2 untuk berkomunikasi dengan pengguna. Jika bot Anda tidak mendukung suara, pilih **Tidak Ada**.

1. Di bagian **ambang batas skor kepercayaan Klasifikasi**, tetapkan nilai yang digunakan Amazon Lex V2 untuk menentukan apakah maksud sudah benar. Anda dapat menyesuaikan nilai ini setelah menguji bot Anda.

1. Pilih **Tambahkan**.

# Menambahkan maksud
<a name="add-intents"></a>

Maksud adalah tujuan yang ingin dicapai pengguna Anda, seperti memesan bunga atau memesan hotel. Bot Anda harus memiliki setidaknya satu niat.

Secara default, semua bot berisi satu maksud bawaan, maksud fallback. Maksud ini digunakan ketika Amazon Lex V2 tidak mengenali maksud lain apa pun. Misalnya, jika pengguna mengatakan “Saya ingin memesan bunga” ke maksud pemesanan hotel, maksud fallback dipicu.

**Untuk menambahkan maksud**

1. Masuk ke AWS Management Console dan buka konsol Amazon Lex di [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).

1. Dari daftar bot, pilih bot yang ingin Anda tambahkan intent, lalu dari **Tambah bahasa pilih **Lihat** bahasa**.

1. Pilih bahasa untuk menambahkan intent, lalu pilih **Intent**.

1. **Pilih **Tambah maksud**, beri nama maksud Anda, lalu pilih Tambah.**

1. Di editor maksud, tambahkan detail maksud Anda.
   + **Alur percakapan** — Gunakan diagram alur percakapan untuk melihat bagaimana dialog dengan bot Anda mungkin terlihat. Anda dapat memilih bagian percakapan yang berbeda untuk beralih ke bagian editor maksud tersebut.
   + **Detail maksud** — Berikan maksud nama dan deskripsi untuk membantu mengidentifikasi tujuan maksud. Anda juga dapat melihat pengenal unik yang ditetapkan Amazon Lex V2 ke intent.
   + **Konteks** - Mengatur konteks input dan output untuk maksud. Konteks adalah variabel status yang terkait dengan maksud. Konteks keluaran diatur ketika maksud terpenuhi. Maksud dengan konteks masukan hanya dapat dikenali jika konteksnya aktif. Maksud tanpa konteks input selalu dapat dikenali.
   + **Contoh ucapan** - Anda harus memberikan 10 frasa atau lebih yang Anda harapkan digunakan pengguna untuk memulai maksud. Amazon Lex V2 menggeneralisasi dari frasa ini untuk mengenali bahwa pengguna ingin memulai maksud.
   + **Respons awal** - Pesan awal yang dikirim ke pengguna setelah intent dipanggil. Anda dapat memberikan respons, menginisialisasi nilai, dan menentukan langkah selanjutnya yang dilakukan Amazon Lex V2 untuk merespons pengguna di awal intent.
   + **Slot** — Tentukan slot, atau parameter, yang diperlukan untuk memenuhi maksud. Setiap slot memiliki tipe yang mendefinisikan nilai yang dapat dimasukkan dalam slot. Anda dapat memilih dari jenis slot khusus Anda, atau Anda dapat memilih jenis slot bawaan.
   + **Konfirmasi** — Permintaan dan tanggapan ini digunakan untuk mengkonfirmasi atau menolak pemenuhan maksud. Permintaan konfirmasi meminta pengguna untuk meninjau nilai slot. Misalnya, “Saya sudah memesan kamar hotel untuk hari Jumat. Apakah ini benar?” Respons deklinasi dikirim ke pengguna ketika mereka menolak konfirmasi. Anda dapat memberikan tanggapan, menetapkan nilai, dan menentukan langkah berikutnya yang diambil Amazon Lex V2 sesuai dengan respons konfirmasi atau deklinasi dari pengguna.
   + **Pemenuhan** — Respon dikirim ke pengguna selama pemenuhan. Anda dapat mengatur pembaruan kemajuan pemenuhan di awal pemenuhan dan secara berkala saat pemenuhan sedang berlangsung. Misalnya, “Saya mengubah kata sandi Anda, ini mungkin memakan waktu beberapa menit” dan “Saya masih mengerjakan permintaan Anda.” Pembaruan pemenuhan hanya digunakan untuk percakapan streaming. Anda juga dapat mengatur pesan sukses pasca-pemenuhan, pesan kegagalan, dan pesan batas waktu. Anda dapat mengirim pesan pasca-pemenuhan untuk streaming dan percakapan reguler. Misalnya, jika pemenuhan berhasil, Anda dapat mengirim “Saya telah mengubah kata sandi Anda.” Jika pemenuhan tidak berhasil, Anda dapat mengirim tanggapan dengan informasi lebih lanjut, seperti “Saya tidak dapat mengubah kata sandi Anda, hubungi meja bantuan untuk bantuan.” Jika pemenuhan memakan waktu lebih lama dari periode batas waktu yang dikonfigurasi, Anda dapat mengirim pesan yang memberi tahu pengguna, seperti “Server kami sangat sibuk saat ini. Coba permintaanmu lagi nanti.” Anda dapat memberikan respons, menetapkan nilai, dan menentukan langkah selanjutnya yang dilakukan Amazon Lex V2 untuk merespons pengguna. 
   + **Menutup tanggapan** — Respons dikirim ke pengguna setelah maksud terpenuhi dan semua pesan lainnya diputar. Misalnya, terima kasih telah memesan kamar hotel. Atau dapat meminta pengguna untuk memulai niat yang berbeda, seperti, “Terima kasih telah memesan kamar, apakah Anda ingin memesan mobil sewaan?” Anda dapat memberikan tanggapan dan mengonfigurasi tindak lanjut tindakan berikutnya setelah memenuhi maksud dan merespons dengan respons penutupan.
   + **Kait kode** - Tunjukkan apakah Anda menggunakan AWS Lambda fungsi untuk menginisialisasi maksud dan memvalidasi input pengguna. Anda menentukan fungsi Lambda dalam alias yang Anda gunakan untuk menjalankan bot.

1. Pilih **Simpan maksud** untuk menyimpan intent.

**catatan**  
Pada 17 Agustus 2022, Amazon Lex V2 merilis perubahan pada cara percakapan dikelola dengan pengguna. Perubahan ini memberi Anda kontrol lebih besar atas jalur yang diambil pengguna melalui percakapan. Untuk informasi selengkapnya, lihat [Perubahan alur percakapan di Amazon Lex V2](understanding-new-flows.md). Bot yang dibuat sebelum 17 Agustus 2022 tidak mendukung pesan kait kode dialog, menyetel nilai, mengonfigurasi langkah selanjutnya, dan menambahkan kondisi.

## Mengkonfigurasi prompt dalam urutan tertentu
<a name="configuring-prompts"></a>

Anda dapat mengonfigurasi bot untuk memutar pesan dalam urutan yang telah ditentukan dengan mencentang kotak untuk **pesan Putar secara berurutan**. Jika tidak, bot memainkan pesan dan variasi dalam urutan acak. 

Permintaan yang dipesan memungkinkan pesan dan variasi grup pesan untuk diputar secara berurutan di antara percobaan ulang. Anda dapat menggunakan rephrasing alternatif pesan ketika respons yang tidak valid untuk prompt diberikan oleh pengguna, atau untuk konfirmasi maksud. Hingga dua variasi pesan asli dapat diatur di setiap slot. Anda dapat memilih apakah akan memutar pesan secara berurutan atau secara acak.

Prompt yang dipesan mendukung keempat jenis pesan: teks, respons muatan khusus, SSML, dan grup kartu. Tanggapan diurutkan dalam grup pesan yang sama. Grup pesan yang berbeda bersifat independen.

**Topics**
+ [Mengkonfigurasi prompt dalam urutan tertentu](#configuring-prompts)
+ [Sampel ucapan](sample-utterances.md)
+ [Struktur niat](intent-structure.md)
+ [Membuat jalur percakapan](building-paths.md)
+ [Menggunakan pembangun percakapan Visual](visual-conversation-builder.md)
+ [Maksud bawaan](built-in-intents.md)

# Sampel ucapan
<a name="sample-utterances"></a>

Anda membuat contoh ucapan yang merupakan variasi frasa yang Anda harapkan digunakan pengguna untuk memulai maksud. Misalnya, untuk **BookFlight** maksud, Anda mungkin menyertakan ucapan seperti berikut ini:

1. Saya ingin memesan penerbangan

1. Bantu aku mendapatkan penerbangan.

1. Tiket pesawat, tolong\$1

1. penerbangan dari \$1*DepartureCity*\$1 ke \$1*DestinationCity*\$1

Anda harus memberikan 10 atau lebih contoh ucapan. Berikan sampel yang mewakili berbagai struktur kalimat dan kata-kata yang dapat diucapkan pengguna. Pertimbangkan juga kalimat yang tidak lengkap, seperti pada contoh 3 dan 4 di atas. Anda juga dapat menggunakan slot yang telah Anda tetapkan untuk maksud dalam contoh ucapan dengan membungkus kurawal kurawal di sekitar nama slot, seperti pada \$1\$1 pada contoh 4. *DepartureCity* Jika Anda menyertakan nama slot dalam contoh ucapan, Amazon Lex V2 mengisi slot maksud dengan nilai yang diberikan pengguna dalam ucapan tersebut.

Berbagai contoh ucapan membantu Amazon Lex V2 menggeneralisasi untuk secara efektif mengenali bahwa pengguna ingin memulai intent.

Anda dapat menambahkan contoh ucapan di editor maksud, pembuat percakapan visual, atau dengan operasi atau API [CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html). [UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html) Anda juga dapat menghasilkan contoh ucapan secara otomatis dengan memanfaatkan kemampuan AI generatif Amazon Bedrock. Untuk informasi selengkapnya, lihat [Gunakan generasi ucapan untuk menghasilkan contoh ucapan untuk pengenalan maksud](utterance-generation.md).

**Menggunakan editor Intent atau pembuat percakapan Visual**

1. Di editor Intent, navigasikan ke bagian **Sample utterances**. Di pembangun percakapan Visual, temukan bagian **Sampel ucapan** di blok **Mulai**.

1. Di kotak dengan teks transparan**I want to book a flight**, ketikkan contoh ucapan. Pilih **Tambahkan ucapan** untuk menambahkan ucapan.

1. Lihat contoh ucapan yang telah Anda tambahkan dalam mode **Pratinjau** atau **teks Biasa**. Dalam **teks Biasa**, setiap baris adalah ucapan yang terpisah. Dalam **mode Pratinjau**, arahkan kursor ke ucapan untuk mengungkapkan opsi berikut:
   + Pilih kotak teks untuk mengedit ucapan.
   + Pilih tombol x di sebelah kanan kotak teks untuk menghapus ucapan.
   + Seret tombol di sebelah kiri kotak teks untuk mengubah urutan ucapan sampel.

1. Gunakan bilah pencarian di bagian atas untuk mencari melalui contoh ucapan Anda dan menu tarik-turun di sebelahnya untuk mengurutkan berdasarkan urutan Anda menambahkan ucapan atau dalam urutan abjad.

**Menggunakan operasi API**

1. Buat maksud baru dengan [CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)operasi atau perbarui yang sudah ada dengan [UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html)operasi.

1. Permintaan API menyertakan `sampleUtterances` bidang, yang memetakan ke array [SampleUtterance](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_SampleUtterance.html)objek.

1. Untuk setiap contoh ucapan yang ingin Anda tambahkan, tambahkan `SampleUtterance` objek ke array. Tambahkan ucapan sampel sebagai nilai bidang. `utterance`

1. Untuk mengedit dan menghapus contoh ucapan, kirim permintaan. `UpdateIntent` Daftar ucapan yang Anda berikan di `sampleUtterances` bidang menggantikan ucapan yang ada.
**penting**  
Bidang apa pun yang Anda biarkan kosong dalam `UpdateIntent` permintaan akan menyebabkan konfigurasi yang ada di intent dihapus. Gunakan [DescribeIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DescribeIntent.html)operasi untuk mengembalikan konfigurasi bot dan menyalin konfigurasi apa pun yang tidak ingin Anda hapus ke dalam `UpdateIntent` permintaan.

# Struktur niat
<a name="intent-structure"></a>

Maksud adalah tujuan yang ingin dicapai pengguna Anda, seperti memesan bunga atau memesan hotel. Bot Anda harus memiliki setidaknya satu niat. Maksud terdiri dari komponen-komponen berikut
+ **Respons awal** - Pesan awal yang dikirim ke pengguna setelah intent dipanggil. Anda dapat mengatur respons, menginisialisasi nilai, dan menentukan langkah selanjutnya yang diambil bot Anda untuk merespons pengguna di awal intent.
+ **Slot** — Parameter yang diperlukan untuk memenuhi maksud. Setiap slot memiliki tipe yang mendefinisikan nilai yang dapat dimasukkan dalam slot. Anda dapat memilih dari jenis slot khusus Anda atau Anda dapat memilih jenis slot bawaan.
+ **Konfirmasi** — Setelah percakapan dengan pengguna selesai dan nilai slot untuk intent terisi, Anda dapat mengatur prompt konfirmasi untuk menanyakan pengguna apakah nilai slot sudah benar.
+ **Pemenuhan** — Respons yang dikirim ke pengguna selama pemenuhan. Anda dapat mengatur pembaruan kemajuan pemenuhan di awal pemenuhan dan terus mengirim pembaruan berkala saat pemenuhan sedang berlangsung. Anda juga dapat mengatur pesan sukses pasca-pemenuhan, pesan kegagalan, dan pesan batas waktu.
+ **Respons penutupan** — Respons penutupan yang dikirim ke pengguna setelah niat mereka terpenuhi. Anda dapat mengatur respons penutupan untuk mengakhiri percakapan, atau Anda dapat mengaturnya agar pengguna tahu bahwa mereka dapat melanjutkan dengan maksud lain.

**Topics**
+ [Respon awal](intent-initial.md)
+ [Slot](intent-slots.md)
+ [Konfirmasi](intent-confirm.md)
+ [Pemenuhan](intent-fulfillment.md)
+ [Tanggapan penutupan](intent-closing.md)

# Respon awal
<a name="intent-initial"></a>

Respons awal dikirim ke pengguna setelah Amazon Lex V2 menentukan maksud dan sebelum mulai memperoleh nilai slot. Anda dapat menggunakan tanggapan ini untuk memberi tahu pengguna tentang maksud yang diakui dan untuk mempersiapkan mereka untuk informasi yang Anda kumpulkan untuk memenuhi maksud tersebut.

Misalnya, jika tujuannya adalah menjadwalkan janji temu layanan untuk mobil, respons awal mungkin:


|  | 
| --- |
| Saya dapat membantu Anda menjadwalkan janji temu. Anda harus menyediakan merek, model, dan tahun mobil Anda. | 

Pesan respons awal tidak diperlukan. Jika Anda tidak menyediakannya, Amazon Lex V2 terus mengikuti langkah berikutnya dari respons awal.

Anda dapat mengonfigurasi opsi berikut dalam respons awal: 
+ **Konfigurasikan langkah berikutnya** — Anda dapat memberikan langkah berikutnya dalam percakapan seperti melompat ke tindakan dialog tertentu, memunculkan slot tertentu, atau melompat ke maksud yang berbeda. Untuk informasi selengkapnya, lihat [Konfigurasikan langkah selanjutnya dalam percakapan](paths-nextstep.md).
+ **Tetapkan nilai** - Anda dapat mengatur nilai untuk slot dan atribut sesi. Untuk informasi selengkapnya, lihat [Tetapkan nilai selama percakapan](paths-setting-values.md)
+ **Tambahkan percabangan bersyarat** — Anda dapat menerapkan kondisi setelah memainkan respons awal. Ketika suatu kondisi dievaluasi menjadi benar, tindakan yang Anda tentukan diambil. Untuk informasi selengkapnya, lihat [Tambahkan kondisi ke percakapan cabang](paths-branching.md).
+ **Jalankan hook kode dialog** - Anda dapat menentukan hook kode Lambda untuk menginisialisasi data dan menjalankan logika bisnis. Untuk informasi selengkapnya, lihat [Memanggil hook kode dialog](paths-code-hook.md). Jika opsi untuk menjalankan fungsi Lambda diaktifkan untuk intent, hook kode dialog dijalankan secara default. Anda dapat menonaktifkan hook kode dialog dengan mengaktifkan tombol **Aktif**.

Dengan tidak adanya kondisi atau langkah eksplisit berikutnya, Amazon Lex V2 pindah ke slot berikutnya dalam urutan prioritas.

![\[Opsi lanjutan untuk respons awal terhadap permintaan pengguna.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/response-initial.png)


**catatan**  
Pada 17 Agustus 2022, Amazon Lex V2 merilis perubahan pada cara percakapan dikelola dengan pengguna. Perubahan ini memberi Anda kontrol lebih besar atas jalur yang diambil pengguna melalui percakapan. Untuk informasi selengkapnya, lihat [Perubahan alur percakapan di Amazon Lex V2](understanding-new-flows.md). Bot yang dibuat sebelum 17 Agustus 2022 tidak mendukung pesan kait kode dialog, menyetel nilai, mengonfigurasi langkah selanjutnya, dan menambahkan kondisi.

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

Slot adalah nilai yang disediakan oleh pengguna untuk memenuhi maksud. Ada dua jenis slot:
+ **Jenis slot bawaan** — Anda dapat menggunakan tipe slot bawaan untuk menangkap nilai standar seperti nomor, nama, dan kota. Untuk daftar jenis slot bawaan yang didukung, lihat[Jenis slot bawaan](built-in-slots.md).
+ **Jenis slot khusus** - Anda dapat menggunakan jenis slot khusus untuk menangkap nilai khusus khusus untuk maksud. Misalnya, Anda dapat menggunakan jenis slot khusus untuk menangkap jenis akun sebagai “Memeriksa” atau “Tabungan”. Untuk informasi selengkapnya, lihat [Jenis slot khusus](custom-slot-types.md).

Untuk menentukan slot dalam intent, Anda harus mengonfigurasi yang berikut ini:
+ **Info slot** — Bidang ini berisi nama dan deskripsi opsional untuk slot. Misalnya, Anda dapat memberikan nama slot sebagai “AccountNumber” untuk menangkap nomor akun. Jika slot diperlukan sebagai bagian dari alur percakapan untuk memenuhi maksud, itu harus ditandai sebagai diperlukan.
+ **Jenis slot** — Jenis slot mendefinisikan daftar nilai yang dapat diterima slot. Anda dapat membuat jenis slot khusus atau menggunakan jenis slot yang telah ditentukan sebelumnya.
+ **Slot prompt — Prompt** slot adalah pertanyaan yang diajukan kepada pengguna untuk mengumpulkan informasi. Anda dapat mengonfigurasi jumlah percobaan ulang yang digunakan untuk mengumpulkan informasi dan variasi prompt yang digunakan untuk setiap percobaan ulang. Anda juga dapat mengaktifkan pemanggilan fungsi Lambda setelah setiap percobaan ulang untuk memproses input yang diambil dan mencoba menyelesaikan ke input yang valid.
+ **Tunggu dan Lanjutkan (opsional)** — Dengan mengaktifkan perilaku ini, pengguna dapat mengucapkan frasa seperti “tahan sebentar” untuk membuat bot menunggu mereka menemukan informasi dan memberikannya. Ini diaktifkan hanya untuk streaming percakapan. Untuk informasi selengkapnya, lihat [Mengaktifkan bot Amazon Lex V2 untuk menunggu pengguna memberikan informasi lebih lanjut selama jeda](wait-and-continue.md).
+ **Respons pengambilan slot** — Anda dapat mengonfigurasi respons sukses dan respons kegagalan berdasarkan hasil menangkap nilai slot dari input pengguna.
+ **Percabangan bersyarat** — Anda dapat menerapkan kondisi setelah memainkan respons awal. Ketika suatu kondisi dievaluasi menjadi benar, tindakan yang Anda tentukan diambil. Untuk informasi selengkapnya, lihat [Tambahkan kondisi ke percakapan cabang](paths-branching.md).
+ **Kait kode dialog — Anda juga dapat menggunakan hook** kode Lambda untuk memvalidasi nilai slot dan menjalankan logika bisnis. Untuk informasi selengkapnya, lihat [Memanggil hook kode dialog](paths-code-hook.md).
+ **Jenis input pengguna** - Anda dapat mengonfigurasi jenis input sehingga bot dapat menerima modalitas tertentu. Secara default, modalitas audio dan DTMF diterima. Anda dapat secara selektif mengaturnya ke audio saja atau DTMF saja.
+ Batas **waktu dan panjang input audio** - Anda dapat mengonfigurasi batas waktu audio termasuk batas waktu suara dan batas waktu diam. Selain itu, Anda dapat mengatur panjang audio maksimal.
+ Batas **waktu input DTMF, karakter, dan panjang** - Anda dapat mengatur batas waktu DTMF bersama dengan karakter penghapusan dan karakter akhir. Juga, Anda dapat mengatur panjang DTMF maks. 
+ **Panjang teks** - Anda dapat mengatur panjang maksimal untuk modalitas teks.

Setelah prompt slot dimainkan, pengguna memberikan nilai slot sebagai input. Jika Amazon Lex V2 tidak memahami nilai slot yang disediakan oleh pengguna, ia mencoba lagi memunculkan slot sampai memahami nilai atau sampai melebihi jumlah percobaan ulang maksimum yang Anda konfigurasikan untuk slot. Dengan menggunakan pengaturan coba lagi lanjutan, Anda dapat mengonfigurasi batas waktu, membatasi jenis input, dan mengaktifkan atau menonaktifkan interupsi untuk prompt awal dan percobaan ulang. Setelah setiap upaya menangkap input, Amazon Lex V2 dapat memanggil fungsi Lambda yang dikonfigurasi untuk bot dengan label pemanggilan yang disediakan untuk percobaan ulang. Anda dapat menggunakan fungsi Lambda, misalnya, untuk menerapkan logika bisnis Anda untuk mencoba menyelesaikannya ke nilai yang valid. Fungsi Lambda ini dapat diaktifkan dalam **Opsi lanjutan untuk permintaan** slot.

![\[Siapkan petunjuk slot agar bot Anda memperoleh informasi.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/response-slot-prompt.png)


Anda dapat menentukan tanggapan yang harus dikirim bot ke pengguna setelah nilai slot dimasukkan atau jika jumlah percobaan ulang maksimum terlampaui. Misalnya, untuk bot untuk layanan penjadwalan untuk mobil, Anda dapat mengirim pesan ke pengguna ketika nomor identifikasi kendaraan (VIN) dimasukkan:


|  | 
| --- |
| Terima kasih telah memberikan nomor VIN mobil Anda. Sekarang saya akan melanjutkan untuk menjadwalkan janji temu. | 

Anda dapat membuat dua tanggapan:
+ **Respon sukses** — dikirim ketika Amazon Lex V2 memahami nilai slot.
+ **Respons kegagalan** — dikirim ketika Amazon Lex V2 tidak dapat memahami nilai slot dari pengguna setelah jumlah maksimum percobaan ulang.

Anda dapat menetapkan nilai, mengonfigurasi langkah selanjutnya, dan menerapkan kondisi yang sesuai dengan setiap respons untuk merancang alur percakapan.

Dengan tidak adanya kondisi atau langkah eksplisit berikutnya, Amazon Lex V2 pindah ke slot berikutnya dalam urutan prioritas.

![\[Opsi lanjutan untuk respons slot.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/response-slot.png)


Anda dapat menggunakan fungsi Lambda untuk memvalidasi nilai slot yang telah dimasukkan pengguna dan menentukan tindakan selanjutnya. Misalnya, Anda dapat menggunakan fungsi validasi untuk memastikan bahwa nilai yang dimasukkan jatuh dalam rentang yang benar, atau yang diformat dengan benar. **Untuk mengaktifkan fungsi Lambda, pilih kotak centang fungsi **Invoke Lambda** dan tombol Aktif di **bagian** kait kode Dialog.** Anda dapat menentukan label pemanggilan untuk hook kode dialog. Label pemanggilan ini dapat digunakan dalam fungsi Lambda untuk menulis logika bisnis yang sesuai dengan elisitasi slot.

![\[Opsi untuk hook kode dialog.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/response-dialog-code-hook.png)


Slot yang tidak diperlukan untuk maksud tersebut bukan bagian dari alur percakapan utama. Namun, jika ucapan pengguna berisi nilai yang diidentifikasi bot Anda sesuai dengan slot opsional, itu dapat memunculkan slot dengan nilai itu. Misalnya, jika Anda mengonfigurasi bot intelijen bisnis untuk memiliki `City` slot opsional dan ucapan pengguna**What is the sales for April in San Diego?**, bot mengisi slot opsional dengan. **San Diego** Anda dapat mengonfigurasi logika bisnis untuk menggunakan nilai slot opsional, jika ada.

Slot yang tidak diperlukan untuk maksud tidak dapat diperoleh menggunakan langkah selanjutnya. Langkah-langkah ini hanya dapat diisi selama elisitasi maksud (seperti pada contoh sebelumnya) atau dapat diperoleh dengan menyetel status dialog dalam fungsi Lambda. Jika slot diperoleh menggunakan fungsi Lambda, Anda harus menggunakan fungsi Lambda untuk memutuskan langkah selanjutnya dalam percakapan setelah elisitasi slot selesai. Untuk mengaktifkan dukungan untuk langkah selanjutnya saat membangun bot, Anda harus menandai slot seperti yang diperlukan untuk maksud tersebut.

**catatan**  
Pada 17 Agustus 2022, Amazon Lex V2 merilis perubahan pada cara percakapan dikelola dengan pengguna. Perubahan ini memberi Anda kontrol lebih besar atas jalur yang diambil pengguna melalui percakapan. Untuk informasi selengkapnya, lihat [Perubahan alur percakapan di Amazon Lex V2](understanding-new-flows.md). Bot yang dibuat sebelum 17 Agustus 2022 tidak mendukung pesan kait kode dialog, menyetel nilai, mengonfigurasi langkah selanjutnya, dan menambahkan kondisi.

Topik berikut menjelaskan cara mengkonfigurasi bot untuk mendapatkan kembali nilai slot yang telah diisi dan cara membuat slot yang terdiri dari beberapa nilai:

**Topics**
+ [Memunculkan kembali slot](reelicit-slots.md)
+ [Menggunakan beberapa nilai dalam slot](multi-valued-slots.md)

# Memunculkan kembali slot
<a name="reelicit-slots"></a>

 Anda dapat mengonfigurasi bot Anda untuk mendapatkan kembali slot yang telah diisi dengan mengatur nilai slot itu **null** dan mengatur langkah berikutnya dalam percakapan untuk kembali ke mendapatkan slot itu. Misalnya, Anda mungkin ingin mendapatkan kembali slot setelah pelanggan Anda menolak konfirmasi elicitation slot berdasarkan informasi tambahan, seperti dalam percakapan berikut: 

![\[Percakapan yang memunculkan preferensi daging pelanggan untuk pesanan makanan.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/slots/order-food.png)


Anda dapat mengonfigurasi loop dari respons konfirmasi kembali untuk mendapatkan kembali slot dengan editor maksud atau editor. [Menggunakan pembangun percakapan Visual](visual-conversation-builder.md)

**catatan**  
Anda dapat memutar kembali untuk mendapatkan kembali slot kapan saja dalam percakapan asalkan Anda menetapkan nilai slot itu sebelumnya. **null**

**Mereproduksi contoh di atas dengan editor maksud**

1. Di bagian **Konfirmasi** editor maksud, pilih panah kanan di sebelah **Prompts untuk mengonfirmasi maksud untuk memperluas bagian**.

1. Pilih **Opsi lanjutan** di bagian bawah.

1. Di bagian **Tolak respons**, pilih panah kanan di sebelah **Tetapkan nilai** untuk memperluas bagian. Isi bagian ini dengan langkah-langkah berikut, seperti pada gambar di bawah ini:

   1. Tetapkan nilai slot yang ingin Anda dapatkan kembali. **null** Dalam contoh ini, kami ingin mendapatkan kembali `Meat` slot, jadi kami masukan **\$1Meat\$1 = null** di bagian Nilai **Slot**.

   1. Di menu tarik-turun di bawah **Langkah berikutnya dalam percakapan**, pilih Dapatkan **slot**.

   1. Bagian **Slot** akan muncul. Di menu tarik-turun di bawahnya, pilih slot yang ingin Anda dapatkan kembali.

   1. Pilih **opsi Perbarui** untuk mengonfirmasi perubahan Anda.  
![\[Percakapan yang memunculkan preferensi daging pelanggan untuk pesanan makanan.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/slots/decline-food.png)

**Mereproduksi contoh di atas dengan pembangun percakapan Visual**

1. Buat koneksi dari **No** port dari blok **Konfirmasi** ke port masuk dari **Get slot value: Meat** block.  
![\[Koneksi dari deklinasi prompt konfirmasi ke blok elisitasi slot Daging.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/slots/vcb-reelicit-slot-loop.png)

1. Pilih ikon **Edit** di sudut kanan atas blok **Konfirmasi**.  
![\[Edit ikon di sudut kanan atas blok konfirmasi.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/slots/vcb-reelicit-slot-confirmation-edit.png)

1. Pilih ikon roda gigi di sebelah respons bot di bagian **respons Decilne**.  
![\[Ikon roda gigi di sebelah respons bot di bagian respons penurunan\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/slots/vcb-reelicit-slot-confirmation.png)

1. Di bagian **Set values**, tambahkan “\$1Meat\$1 = null” di kotak **Nilai Slot**.  
![\[Atur nilai slot yang akan ditimbulkan kembali ke null di kotak nilai slot dari bagian nilai set.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/slots/vcb-reelicit-slot-set-slot-null.png)

1. Pilih **Simpan Maksud.**

# Menggunakan beberapa nilai dalam slot
<a name="multi-valued-slots"></a>

**catatan**  
Beberapa slot nilai hanya didukung dalam bahasa Inggris (AS).

Untuk beberapa maksud, Anda mungkin ingin menangkap beberapa nilai untuk satu slot. Misalnya, bot pemesanan pizza mungkin memiliki maksud dengan ucapan berikut:

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

Maksudnya mengharapkan bahwa `{toppings}` slot berisi daftar topping yang diinginkan pelanggan di pizza mereka, misalnya “pepperoni dan nanas”.

Untuk mengonfigurasi slot untuk menangkap beberapa nilai, Anda mengatur `allowMultipleValues` bidang pada slot ke true. Anda dapat mengatur bidang menggunakan konsol atau dengan [UpdateSlot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateSlot.html)operasi [CreateSlot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateSlot.html)atau.

Anda hanya dapat menandai slot dengan jenis slot khusus sebagai slot multi-nilai.

Untuk slot multi-nilai, Amazon Lex V2 mengembalikan daftar nilai slot sebagai respons terhadap [RecognizeUtterance](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeUtterance.html)operasi [RecognizeText](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeText.html)atau. Berikut ini adalah informasi slot yang dikembalikan untuk ucapan “Saya ingin pizza dengan pepperoni dan nanas” dari bot. 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"
                        ]
                    }
                }
            ]
        }
    }
```

Slot multi-nilai selalu mengembalikan daftar nilai. Ketika ucapan hanya berisi satu nilai, daftar nilai yang dikembalikan hanya berisi satu respons. 

Amazon Lex V2 mengenali beberapa nilai yang dipisahkan oleh spasi, koma (,), dan konjungsi “dan”. Slot multi-nilai bekerja dengan input teks dan suara.

Anda dapat menggunakan slot multi-nilai dalam petunjuk. Misalnya, Anda dapat mengatur prompt konfirmasi untuk maksud

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

Ketika Amazon Lex V2 mengirimkan prompt ke pengguna, ia mengirimkan “Apakah Anda ingin saya memesan pizza pepperoni dan nanas Anda?”

Slot multi-nilai mendukung nilai default tunggal. Jika beberapa nilai default disediakan, Amazon Lex V2 mengisi slot dengan hanya nilai pertama yang tersedia. Untuk informasi selengkapnya, lihat [Menggunakan nilai slot default dalam maksud untuk bot Lex V2 Anda](context-mgmt-default.md).

Anda dapat menggunakan slot obfuscation untuk menutupi nilai slot multi-nilai di log percakapan. Saat Anda mengaburkan nilai slot, nilai masing-masing nilai slot diganti dengan nama slot. Lihat informasi yang lebih lengkap di [Mengaburkan nilai slot dalam log percakapan dari Lex V2](monitoring-obfuscate.md).

# Konfirmasi
<a name="intent-confirm"></a>

Setelah percakapan dengan pengguna selesai dan nilai slot untuk intent terisi, Anda dapat mengonfigurasi prompt konfirmasi untuk menanyakan kepada pengguna apakah nilai slot sudah benar. Misalnya, bot yang menjadwalkan janji temu layanan untuk mobil mungkin meminta pengguna dengan hal-hal berikut:


|  | 
| --- |
| Saya punya layanan untuk Honda Civic 2017 Anda yang dijadwalkan pada 25 Maret pukul 15.00. Apakah itu semua benar? | 

Anda dapat menentukan 3 jenis tanggapan terhadap prompt konfirmasi:
+ **Respons konfirmasi** - Respons ini dikirim ke pengguna saat pengguna mengonfirmasi maksud. Misalnya, setelah pengguna menjawab “ya” ke prompt “apakah Anda ingin melakukan pemesanan?”
+ **Respons tolak** - Respons ini dikirim ke pengguna saat pengguna menolak maksud. Misalnya, setelah pengguna membalas “tidak” ke prompt “apakah Anda ingin melakukan pemesanan?”
+ **Respons kegagalan** - Respons ini dikirim ke pengguna ketika prompt konfirmasi tidak dapat diproses. Misalnya, jika respons pengguna tidak dapat dipahami atau tidak dapat diselesaikan menjadi ya atau tidak. 

![\[Diagram alur yang menunjukkan 3 jenis respons untuk konfirmasi dan respons penurunan.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/conditional-confirmation-flow.png)


Jika Anda tidak menentukan prompt konfirmasi, Amazon Lex V2 pindah ke langkah pemenuhan atau respons penutupan. 

Anda dapat menetapkan nilai, mengonfigurasi langkah berikutnya, dan menerapkan kondisi yang sesuai dengan setiap respons untuk merancang alur percakapan. Dengan tidak adanya kondisi atau langkah eksplisit berikutnya, Amazon Lex V2 pindah ke langkah pemenuhan. 

Anda juga dapat mengaktifkan hook kode dialog untuk memvalidasi informasi yang ditangkap dalam intent sebelum mengirimnya untuk pemenuhan. Untuk menggunakan hook kode, aktifkan hook kode dialog di opsi lanjutan prompt konfirmasi. Selain itu, konfigurasikan langkah selanjutnya dari status sebelumnya untuk mengeksekusi hook kode dialog. Untuk informasi selengkapnya, lihat [Memanggil hook kode dialog](paths-code-hook.md). 

**catatan**  
 Jika Anda menggunakan hook kode untuk memicu langkah konfirmasi saat runtime, Anda harus menandai langkah konfirmasi sebagai **Aktif** pada waktu pembuatan. 

![\[Konsol Amazon Lex V2 menunjukkan opsi lanjutan untuk permintaan konfirmasi.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/response-confirm.png)


**catatan**  
Pada 17 Agustus 2022, Amazon Lex V2 merilis perubahan pada cara percakapan dikelola dengan pengguna. Perubahan ini memberi Anda kontrol lebih besar atas jalur yang diambil pengguna melalui percakapan. Untuk informasi selengkapnya, lihat [Perubahan alur percakapan di Amazon Lex V2](understanding-new-flows.md). Bot yang dibuat sebelum 17 Agustus 2022 tidak mendukung pesan kait kode dialog, menyetel nilai, mengonfigurasi langkah selanjutnya, dan menambahkan kondisi.

## Menggunakan fungsi Lambda untuk memvalidasi intent.
<a name="intent-confirm-codehook"></a>

Anda dapat menentukan hook kode Lambda untuk memvalidasi intent sebelum mengirimnya untuk pemenuhan. Untuk menggunakan hook kode, aktifkan hook kode dialog di opsi lanjutan prompt konfirmasi.

Saat Anda menggunakan kait kode, Anda dapat menentukan tindakan yang dilakukan Amazon Lex V2 setelah hook kode berjalan. Anda dapat membuat tiga jenis tanggapan:
+ **Respon sukses** - Dikirim ke pengguna ketika hook kode selesai dengan sukses.
+ **Respons kegagalan** - Dikirim ke pengguna ketika hook kode tidak berjalan dengan sukses atau ketika hook kode kembali `Failure` dalam respons.
+ **Respons batas waktu** - Dikirim ke pengguna saat kait kode tidak selesai dalam periode batas waktu yang dikonfigurasi.

# Pemenuhan
<a name="intent-fulfillment"></a>

Setelah semua nilai slot disediakan oleh pengguna untuk maksud tersebut, Amazon Lex V2 memenuhi permintaan pengguna. Anda dapat mengonfigurasi opsi berikut untuk pemenuhan.
+ **Hook kode pemenuhan** - Anda dapat menggunakan opsi ini untuk mengontrol pemenuhan pemanggilan Lambda. Jika opsi dinonaktifkan, pemenuhan berhasil tanpa menjalankan fungsi Lambda.
+ **Pembaruan pemenuhan** - Anda dapat mengaktifkan pembaruan pemenuhan untuk fungsi Lambda yang membutuhkan waktu lebih dari beberapa detik untuk diselesaikan, sehingga pengguna tahu bahwa prosesnya sedang berlangsung. Untuk informasi selengkapnya, lihat [Mengkonfigurasi pembaruan kemajuan pemenuhan untuk bot Lex V2 Anda](streaming-progress.md). Fungsionalitas ini hanya tersedia untuk streaming percakapan.
+ **Respons pemenuhan** — Anda dapat mengonfigurasi respons sukses, respons kegagalan, dan respons batas waktu. Respons yang sesuai dikembalikan ke pengguna berdasarkan status pemenuhan pemanggilan Lambda.

Ada tiga kemungkinan tanggapan pemenuhan:
+ **Respon sukses** — Pesan yang dikirim ketika pemenuhan Lambda selesai dengan sukses.
+ **Respons kegagalan** — Pesan yang dikirim jika pemenuhan gagal atau Lambda tidak dapat diselesaikan karena alasan tertentu.
+ **Respons batas waktu** - Pesan yang dikirim jika fungsi Lambda pemenuhan tidak selesai dalam batas waktu yang dikonfigurasi.

Anda dapat menetapkan nilai, mengonfigurasi langkah berikutnya, dan menerapkan kondisi yang sesuai dengan setiap respons untuk merancang alur percakapan. Dengan tidak adanya kondisi atau langkah eksplisit berikutnya, Amazon Lex V2 beralih ke respons penutupan. 

![\[Konsol Amazon Lex V2 menampilkan opsi respons untuk hook kode pemenuhan.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/response-fulfillment.png)


**catatan**  
Pada 17 Agustus 2022, Amazon Lex V2 merilis perubahan pada cara percakapan dikelola dengan pengguna. Perubahan ini memberi Anda kontrol lebih besar atas jalur yang diambil pengguna melalui percakapan. Untuk informasi selengkapnya, lihat [Perubahan alur percakapan di Amazon Lex V2](understanding-new-flows.md). Bot yang dibuat sebelum 17 Agustus 2022 tidak mendukung pesan kait kode dialog, menyetel nilai, mengonfigurasi langkah selanjutnya, dan menambahkan kondisi.

# Tanggapan penutupan
<a name="intent-closing"></a>

Respons penutupan dikirim ke pengguna Anda setelah maksud mereka terpenuhi. Anda dapat menggunakan respons penutup untuk mengakhiri percakapan, atau Anda dapat menggunakannya untuk memberi tahu pengguna bahwa mereka dapat melanjutkan dengan maksud lain. Misalnya, dalam bot pemesanan perjalanan, Anda dapat mengatur respons penutupan untuk maksud kamar hotel buku untuk ini:


|  | 
| --- |
| Baiklah, aku sudah memesan kamar hotelmu. Apakah ada hal lain yang bisa saya bantu?  | 

Anda dapat menetapkan nilai, mengonfigurasi langkah selanjutnya, dan menerapkan kondisi setelah respons penutupan untuk merancang jalur percakapan. Dengan tidak adanya kondisi atau langkah eksplisit berikutnya, Amazon Lex V2 mengakhiri percakapan. 

Jika Anda tidak memberikan respons penutup, atau jika tidak ada kondisi yang benar, Amazon Lex V2 mengakhiri percakapan dengan bot Anda.

![\[Konsol Amazon Lex V2 menunjukkan opsi untuk menutup respons.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/response-closing.png)


**catatan**  
Pada 17 Agustus 2022, Amazon Lex V2 merilis perubahan pada cara percakapan dikelola dengan pengguna. Perubahan ini memberi Anda kontrol lebih besar atas jalur yang diambil pengguna melalui percakapan. Untuk informasi selengkapnya, lihat [Perubahan alur percakapan di Amazon Lex V2](understanding-new-flows.md). Bot yang dibuat sebelum 17 Agustus 2022 tidak mendukung pesan kait kode dialog, menyetel nilai, mengonfigurasi langkah selanjutnya, dan menambahkan kondisi.

# Membuat jalur percakapan
<a name="building-paths"></a>

Biasanya, Amazon Lex V2 mengelola aliran percakapan dengan pengguna Anda. Untuk bot sederhana, aliran default bisa cukup untuk menciptakan pengalaman yang baik bagi pengguna Anda. Namun, untuk bot yang lebih kompleks, Anda mungkin ingin mengendalikan percakapan dan mengarahkan aliran ke jalur yang lebih kompleks.

Misalnya, dalam bot yang memesan persewaan mobil, Anda mungkin tidak menyewakan kepada pengemudi yang lebih muda. Dalam hal ini, Anda dapat membuat kondisi yang memeriksa untuk melihat apakah pengemudi di bawah usia tertentu, dan jika demikian, lompat ke respons penutupan. 

![\[Diagram alur yang menunjukkan alur percakapan untuk bot penyewaan mobil yang tidak disewakan kepada pengemudi di bawah 24 tahun.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/conditional-flowchart.png)


Untuk merancang interaksi seperti itu, Anda dapat mengonfigurasi langkah berikutnya di setiap titik dalam percakapan, mengevaluasi kondisi, menetapkan nilai, dan memanggil kait kode.

Percabangan bersyarat membantu Anda membuat jalur untuk pengguna melalui interaksi yang kompleks. Anda dapat menggunakan cabang bersyarat kapan saja Anda melewati kendali percakapan ke bot Anda. Misalnya, Anda dapat membuat kondisi sebelum bot memunculkan nilai slot pertama, Anda dapat membuat kondisi antara memunculkan setiap nilai slot, atau Anda dapat membuat kondisi sebelum bot menutup percakapan. Untuk daftar tempat yang dapat Anda tambahkan kondisi, lihat[Menambahkan maksud](add-intents.md).

Saat Anda membuat bot, Amazon Lex V2 membuat jalur default melalui percakapan berdasarkan urutan prioritas slot. Untuk menyesuaikan jalur percakapan, Anda dapat mengubah langkah berikutnya kapan saja dalam percakapan. Untuk informasi selengkapnya, lihat [Konfigurasikan langkah selanjutnya dalam percakapan](paths-nextstep.md). 

Untuk membuat jalur alternatif berdasarkan kondisi, Anda dapat menggunakan cabang bersyarat kapan saja dalam percakapan. Misalnya, Anda dapat membuat kondisi sebelum bot memunculkan nilai slot pertama. Anda dapat membuat kondisi antara memunculkan setiap nilai slot, atau Anda dapat membuat kondisi sebelum bot menutup percakapan. Untuk daftar tempat yang memungkinkan Anda menambahkan kondisi, lihat[Tambahkan kondisi ke percakapan cabang](paths-branching.md).

Anda dapat mengatur kondisi berdasarkan nilai slot, atribut sesi, mode input dan transkrip input, atau respons dari Amazon Kendra. 

Anda dapat mengatur nilai atribut slot dan sesi di setiap titik dalam percakapan. Untuk informasi selengkapnya, lihat [Tetapkan nilai selama percakapan](paths-setting-values.md).

Anda juga dapat mengatur tindakan berikutnya ke hook kode dialog untuk menjalankan fungsi Lambda. Untuk informasi selengkapnya, lihat [Memanggil hook kode dialog](paths-code-hook.md). 

Gambar berikut menunjukkan pembuatan jalur untuk slot di konsol. Dalam contoh ini, Amazon Lex V2 akan memperoleh slot “usia”. Jika nilai slot kurang dari 24, Amazon Lex V2 melompat ke respons penutupan, jika tidak Amazon Lex V2 akan mengikuti jalur default.

![\[Konsol Amazon Lex V2 menunjukkan editor kondisi untuk slot.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/conditional-slot.png)


**catatan**  
Pada 17 Agustus 2022, Amazon Lex V2 merilis perubahan pada cara percakapan dikelola dengan pengguna. Perubahan ini memberi Anda kontrol lebih besar atas jalur yang diambil pengguna melalui percakapan. Untuk informasi selengkapnya, lihat [Perubahan alur percakapan di Amazon Lex V2](understanding-new-flows.md). Bot yang dibuat sebelum 17 Agustus 2022 tidak mendukung pesan kait kode dialog, menyetel nilai, mengonfigurasi langkah selanjutnya, dan menambahkan kondisi.

# Konfigurasikan langkah selanjutnya dalam percakapan
<a name="paths-nextstep"></a>

Anda dapat mengonfigurasi langkah berikutnya di setiap tahap percakapan untuk merancang percakapan. Biasanya, Amazon Lex V2 secara otomatis mengonfigurasi langkah default berikutnya untuk setiap tahap percakapan sesuai urutan berikut.

 Respon Awal → Elisitasi Slot → Konfirmasi (jika aktif) → Pemenuhan (jika aktif) → Respon Penutupan (jika aktif) → Akhiri percakapan

Anda dapat memodifikasi langkah default berikutnya dan mendesain percakapan berdasarkan pengalaman pengguna yang diharapkan. Langkah-langkah berikut selanjutnya dapat dikonfigurasi pada setiap tahap percakapan:

**Lompat ke**
+ **Respon awal** — Percakapan dimulai kembali dari awal niat. Anda dapat memilih untuk melewati respons awal saat mengonfigurasi langkah berikutnya
+ **Dapatkan slot — Anda dapat memperoleh slot** apa pun dalam maksud.
+ **Evaluasi kondisi** — Anda dapat mengevaluasi kondisi dan percakapan cabang pada setiap langkah percakapan.
+ **Memanggil kode dialog hook** - Anda dapat menjalankan logika bisnis pada langkah apa pun.
+ **Konfirmasi maksud** — Pengguna akan diminta untuk mengonfirmasi maksud.
+ **Memenuhi niat** — Pemenuhan niat akan dimulai sebagai langkah berikutnya.
+ **Respons penutupan** - Respons penutupan akan dikembalikan ke pengguna.

**Beralih ke**
+ **Maksud** — Anda dapat beralih ke maksud yang berbeda dan melanjutkan percakapan untuk maksud ini. Secara opsional, Anda dapat melewatkan respons awal intent saat melakukan transisi.
+ **Maksud: slot khusus** — Anda dapat langsung memperoleh slot tertentu dalam maksud yang berbeda jika Anda telah menangkap beberapa nilai slot dalam maksud saat ini.

**Tunggu masukan pengguna** — Bot menunggu pengguna memberikan input untuk mengenali maksud baru apa pun. Anda dapat mengonfigurasi petunjuk seperti “Apakah ada hal lain yang dapat saya bantu?” sebelum menetapkan langkah selanjutnya. Bot akan berada dalam status `ElicitIntent` dialog.

**Akhiri percakapan** — Percakapan dengan bot ditutup.

**catatan**  
Pada 17 Agustus 2022, Amazon Lex V2 merilis perubahan pada cara percakapan dikelola dengan pengguna. Perubahan ini memberi Anda kontrol lebih besar atas jalur yang diambil pengguna melalui percakapan. Untuk informasi selengkapnya, lihat [Perubahan alur percakapan di Amazon Lex V2](understanding-new-flows.md). Bot yang dibuat sebelum 17 Agustus 2022 tidak mendukung pesan kait kode dialog, menyetel nilai, mengonfigurasi langkah selanjutnya, dan menambahkan kondisi.

# Tetapkan nilai selama percakapan
<a name="paths-setting-values"></a>

Amazon Lex V2 menyediakan kemampuan untuk mengatur nilai slot dan nilai atribut sesi di setiap langkah percakapan. Anda kemudian dapat menggunakan nilai-nilai ini selama percakapan untuk mengevaluasi kondisi atau menggunakannya selama pemenuhan maksud.

Anda dapat mengatur nilai slot untuk maksud saat ini. Jika langkah selanjutnya dalam percakapan adalah memanggil intent lain, Anda dapat menetapkan nilai slot dari intent baru.

Jika slot yang ditetapkan tidak diisi, atau jika jalur JSON tidak dapat diuraikan, maka atribut akan disetel ke. `null`

Gunakan sintaks berikut saat menggunakan nilai slot dan atribut sesi:
+ **Nilai slot** — mengelilingi nama slot dengan kawat gigi (“\$1\$1”). Untuk nilai slot di intent saat ini, Anda hanya perlu menggunakan nama slot. Misalnya, `{slot}`. Jika Anda menetapkan nilai di intent berikutnya, Anda harus menggunakan nama maksud dan nama slot untuk mengidentifikasi slot. Misalnya, `{intent.slot}`.

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

  Nilai slot dapat berupa salah satu dari yang berikut:
  + string konstan
  + jalur JSON yang mengacu pada blok transkripsi dalam respons Amazon Lex (untuk en-US dan en-GB)
  + atribut sesi

  Contoh:
  +  `{username} = "john.doe" ` 
  +  `{username_confidence} = $.transcriptions[0].transcriptionConfidence ` 
  +  `{username_slot_value} = [username] ` 
**catatan**  
Nilai slot juga dapat diatur ke`null`. Jika Anda perlu mendapatkan kembali nilai slot yang telah diisi, Anda harus menetapkan nilainya `null` sebelum meminta pelanggan untuk nilai slot lagi. Jika slot yang ditetapkan tidak diisi, atau jika jalur JSON tidak dapat diuraikan, maka atribut akan disetel ke. `null`
+ **Atribut sesi** — mengelilingi nama atribut dengan tanda kurung siku (“[]”). Misalnya, `[sessionAttribute]`.

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

  Nilai atribut sesi dapat berupa salah satu dari berikut ini:
  + string konstan
  + jalur JSON yang mengacu pada blok transkripsi dalam respons Amazon Lex (untuk en-US dan en-GB)
  + referensi nilai slot
**catatan**  
Jika slot yang ditetapkan tidak diisi, atau jika jalur JSON tidak dapat diuraikan, maka atribut akan disetel ke. `null`

**catatan**  
Pada 17 Agustus 2022, Amazon Lex V2 merilis perubahan pada cara percakapan dikelola dengan pengguna. Perubahan ini memberi Anda kontrol lebih besar atas jalur yang diambil pengguna melalui percakapan. Untuk informasi selengkapnya, lihat [Perubahan alur percakapan di Amazon Lex V2](understanding-new-flows.md). Bot yang dibuat sebelum 17 Agustus 2022 tidak mendukung pesan kait kode dialog, menyetel nilai, mengonfigurasi langkah selanjutnya, dan menambahkan kondisi.

# Tambahkan kondisi ke percakapan cabang
<a name="paths-branching"></a>

Anda dapat menggunakan *percabangan bersyarat* untuk mengontrol jalur yang diambil pelanggan Anda melalui percakapan dengan bot Anda. Anda dapat mem-cabang percakapan berdasarkan nilai slot, atribut sesi, isi mode input dan bidang transkrip input, atau respons dari Amazon Kendra.

Anda dapat menentukan hingga empat cabang. Setiap cabang memiliki kondisi yang harus dipenuhi agar Amazon Lex V2 mengikuti cabang itu. Jika tidak ada cabang yang kondisinya terpenuhi, cabang default diikuti.

Saat Anda mendefinisikan cabang, Anda menentukan tindakan yang harus dilakukan Amazon Lex V2 jika kondisi yang sesuai dengan cabang tersebut dievaluasi menjadi true. Anda dapat menentukan salah satu tindakan berikut:
+ Tanggapan dikirim ke pengguna.
+ Nilai slot untuk diterapkan ke slot.
+ Nilai atribut sesi untuk sesi saat ini.
+ Langkah selanjutnya dalam percakapan. Untuk informasi selengkapnya, lihat [Membuat jalur percakapan](building-paths.md).

![\[Anda dapat memilih opsi yang berbeda untuk percabangan bersyarat.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/conditional-choose.png)


Setiap cabang kondisional memiliki ekspresi Boolean yang harus dipenuhi untuk Amazon Lex V2 untuk mengikuti cabang. Ada operator perbandingan dan Boolean, fungsi, dan operator kuantifier yang dapat Anda gunakan untuk kondisi Anda. Misalnya, kondisi berikut mengembalikan nilai true jika slot \$1age\$1 kurang dari 24.

```
{age} < 24
```

Kondisi berikut mengembalikan nilai true jika slot multi-nilai \$1toppings\$1 berisi kata “nanas”.

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

Anda dapat menggabungkan beberapa operator perbandingan dengan operator Boolean untuk kondisi yang lebih kompleks. Misalnya, kondisi berikut mengembalikan nilai true jika nilai slot \$1make\$1 adalah “Honda” dan nilai slot \$1model\$1 adalah “Civic”. Gunakan tanda kurung untuk mengatur urutan evaluasi.

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

Topik berikut memberikan rincian tentang operator dan fungsi cabang bersyarat.

**catatan**  
Pada 17 Agustus 2022, Amazon Lex V2 merilis perubahan pada cara percakapan dikelola dengan pengguna. Perubahan ini memberi Anda kontrol lebih besar atas jalur yang diambil pengguna melalui percakapan. Untuk informasi selengkapnya, lihat [Perubahan alur percakapan di Amazon Lex V2](understanding-new-flows.md). Bot yang dibuat sebelum 17 Agustus 2022 tidak mendukung pesan kait kode dialog, menyetel nilai, mengonfigurasi langkah selanjutnya, dan menambahkan kondisi.

**Topics**
+ [Operator perbandingan](#branching-comparison)
+ [Operator Boolean](#branching-boolean)
+ [Operator kuantifier](#branching-quentifier)
+ [Fungsi](#branching-function)
+ [Contoh ekspresi bersyarat](#sample-conditional-expressions)

## Operator perbandingan
<a name="branching-comparison"></a>

Amazon Lex V2 mendukung operator perbandingan berikut untuk kondisi:
+ Sama dengan (=)
+ Tidak sama (\$1 =)
+ Kurang dari (<)
+ Kurang dari atau sama (<=)
+ Lebih besar dari (>)
+ Lebih besar dari atau sama (>=)

Saat menggunakan operator perbandingan, ia menggunakan aturan berikut.
+ Sisi kiri harus menjadi referensi. Misalnya, untuk referensi nilai slot, Anda menggunakan`{slotName}`. Untuk mereferensikan nilai atribut sesi, Anda menggunakan`[attribute]`. Untuk mode input dan transkrip input, Anda menggunakan `$.inputMode` dan`$.inputTranscript`.
+ Sisi kanan harus konstan dan tipe yang sama dengan sisi kiri.
+ Ekspresi apa pun yang mereferensikan atribut yang belum disetel diperlakukan sebagai tidak valid, dan tidak dievaluasi.
+ Ketika Anda membandingkan slot multi-nilai, nilai yang digunakan adalah daftar dipisahkan koma dari semua nilai yang ditafsirkan.

Perbandingan didasarkan pada jenis slot referensi. Mereka diselesaikan sebagai berikut:
+ **String** — string dibandingkan berdasarkan representasi ASCII mereka. Perbandingannya tidak peka huruf besar/kecil.
+ **Nomor** — slot berbasis angka dikonversi dari representasi string ke angka dan kemudian dibandingkan.
+ **Tanggal/Waktu** — slot berbasis waktu dibandingkan berdasarkan deret waktu. Tanggal atau waktu sebelumnya dianggap lebih kecil. Untuk jangka waktu, periode yang lebih pendek dianggap lebih kecil. 

## Operator Boolean
<a name="branching-boolean"></a>

Amazon Lex V2 mendukung operator Boolean untuk menggabungkan operator perbandingan. Mereka memungkinkan Anda membuat pernyataan yang mirip dengan berikut ini:

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

Anda dapat menggunakan operator Boolean berikut:
+ DAN (&&)
+ ATAU (\$1\$1)
+ TIDAK (\$1)

## Operator kuantifier
<a name="branching-quentifier"></a>

Operator kuantifier mengevaluasi elemen urutan dan menentukan apakah satu atau lebih elemen memenuhi kondisi.
+ **CONTAINS** — menentukan apakah nilai yang ditentukan terkandung dalam slot multi-nilai dan mengembalikan true jika itu. Misalnya, `{toppings} CONTAINS "pineapple"` mengembalikan true jika pengguna memesan nanas di pizza mereka.

## Fungsi
<a name="branching-function"></a>

Fungsi harus diawali dengan string`fn.`. Argumen untuk fungsi adalah referensi ke slot, atribut sesi, atau atribut permintaan. Amazon Lex V2 menyediakan dua fungsi untuk mendapatkan informasi dari nilai slot, SessionAttribute, atau RequestAttribute.
+ **Fn.count ()** — menghitung jumlah nilai dalam slot multi-nilai. 

  Misalnya, jika slot `{toppings}` berisi nilai “pepperoni, nanas”:

  `fn.COUNT({toppings}) = 2`
+ **fn.is\$1set ()** — nilai true jika slot, atribut sesi, atau atribut permintaan diatur dalam sesi saat ini.

  Berdasarkan contoh sebelumnya:

  `fn.IS_SET({toppings})`
+ **fn.length ()** - nilai adalah panjang dari nilai atribut sesi, nilai slot, atau atribut slot yang diatur dalam sesi saat ini. Fungsi ini tidak mendukung slot multi-nilai atau slot komposit.

  Contoh:

  Jika slot `{credit-card-number}` berisi nilai “123456781234":

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

## Contoh ekspresi bersyarat
<a name="sample-conditional-expressions"></a>

Berikut adalah beberapa contoh ekspresi kondisional. CATATAN: `$.` mewakili titik masuk ke respons Amazon Lex V2 JSON. Nilai berikut `$.` akan diuraikan dalam respons Amazon Lex V2 untuk mengambil nilainya. Ekspresi bersyarat menggunakan referensi jalur JSON ke blok transkripsi di respons Amazon Lex V2 hanya akan didukung di lokal yang sama yang mendukung skor transkripsi ASR.


| Tipe nilai | Kasus penggunaan | Ekspresi bersyarat | 
| --- | --- | --- | 
| Slot khusus | pizzaSizenilai slot sama dengan besar | \$1pizzaSize\$1 = "large" | 
| Slot khusus | pizzaSizesama dengan besar atau sedang | \$1pizzaSize\$1 = "large"ATAU \$1pizzaSize\$1 = "medium"  | 
| Slot khusus | Ekspresi dengan () dan AND/OR | \$1pizzaType\$1 = "pepperoni"ATAU \$1pizzaSize\$1 = "medium" ATAU \$1pizzaSize\$1 = "small"  | 
| Slot khusus (Slot Multi-Nilai) | Periksa apakah salah satu toppingnya adalah Onion | \$1toppings\$1 CONTAINS "Onion" | 
| Slot khusus (Slot Multi-Nilai) | Jumlah topping lebih dari 3 | fn.COUNT(\$1topping\$1) > 2 | 
| AMAZON.AlphaNumeric | bookingIDadalah ABC123 | \$1bookingID\$1 = "ABC123" | 
| AMAZON.Number | nilai slot usia lebih besar dari 30 | \$1age\$1 > 30 | 
| AMAZON.Number | nilai slot usia sama dengan 10 | \$1age\$1 = 10 | 
| AMAZON.Date | dateOfBirthnilai slot sebelum 1990 | \$1dateOfBirth\$1 < "1990-10-01" | 
| AMAZON.State | destinationStatenilai slot sama dengan Washington | \$1destinationState\$1 = "washington" | 
| AMAZON.Country | destinationCountrynilai slot bukan Amerika Serikat | \$1destinationCountry\$1 \$1= "united states" | 
| AMAZON.FirstName | firstNameNilai slot adalah John | \$1firstName\$1 = "John" | 
| AMAZON.PhoneNumber | phoneNumbernilai slot adalah 716767891932 | \$1phoneNumer\$1 = 716767891932 | 
| AMAZON.Percentage | Periksa apakah persentase nilai slot lebih besar dari atau sama dengan 78 | \$1percentage\$1 >= 78 | 
| AMAZON.EmailAddress | emailAddressnilai slot adalah userA@hmail.com | \$1emailAddress\$1 = "userA@hmail.com" | 
| AMAZON.LastName | lastNamenilai slot adalah Doe | \$1lastName\$1 = "Doe" | 
| AMAZON.City | Nilai slot kota sama dengan Seattle | \$1city\$1 = "Seattle" | 
| AMAZON.Time | Waktu setelah jam 8 malam | \$1time\$1 > "20:00" | 
| AMAZON.StreetName | streetNamenilai slot adalah Boren Avenue | \$1streetName\$1 = "boren avenue" | 
| AMAZON.Duration | travelDurationnilai slot kurang dari 2 jam | \$1travelDuration\$1 < P2H | 
| Modus masukan | Mode input adalah ucapan | \$1.inputMode = "Speech" | 
| Transkrip masukan | Transkrip masukan sama dengan “Saya ingin pizza besar” | \$1.inputTranscript = "I want a large pizza" | 
| Atribut sesi | periksa atribut customer\$1subscription\$1type | [customer\$1subcription\$1type] = "yearly" | 
| Atribut permintaan | periksa bendera retry\$1enabled | ((retry\$1enabled)) = "TRUE" | 
| Tanggapan Kendra | Tanggapan Kendra berisi FAQ | fn.IS\$1SET(((x-amz-lex:kendra-search-response-question\$1answer-question-1))) | 
| Ekspresi bersyarat dengan transkripsi | Ekspresi bersyarat menggunakan transkripsi jalur JSON | \$1.transcriptions[0].transcriptionConfidence < 0.8 AND \$1.transcriptions[1].transcriptionConfidence > 0.5 | 
| Tetapkan atribut sesi | Atur atribut sesi menggunakan transkripsi jalur JSON dan nilai slot | [sessionAttribute] = "\$1.transcriptions..." AND [sessionAttribute] = "\$1<slotName>\$1" | 
| Tetapkan nilai slot | Tetapkan nilai slot menggunakan atribut sesi dan transkripsi jalur JSON | \$1slotName\$1 = [<sessionAttribute>] AND \$1slotName\$1 = "\$1.transcriptions..." | 

**catatan**  
`slotName`mengacu pada nama slot di bot Amazon Lex V2. Jika slot tidak diselesaikan (null), atau jika slot tidak ada, maka tugas diabaikan saat runtime. `sessionAttribute`mengacu pada nama atribut sesi yang ditetapkan oleh pelanggan pada waktu pembuatan.

# Memanggil hook kode dialog
<a name="paths-code-hook"></a>

Pada setiap langkah dalam percakapan ketika Amazon Lex V2 mengirim pesan ke pengguna, Anda dapat menggunakan fungsi Lambda sebagai langkah berikutnya dalam percakapan. Anda dapat menggunakan fungsi untuk mengimplementasikan logika bisnis berdasarkan keadaan percakapan saat ini.

Fungsi Lambda yang berjalan dikaitkan dengan alias bot yang Anda gunakan. Untuk menjalankan fungsi Lambda di semua kait kode dialog di intent Anda, Anda harus memilih **Gunakan fungsi Lambda untuk menginisialisasi** dan memvalidasi maksud. Untuk informasi selengkapnya tentang memilih fungsi Lambda, lihat. [Membuat AWS Lambda fungsi untuk bot Amazon Lex V2 Anda](lambda-attach.md)

Ada dua langkah untuk menggunakan fungsi Lambda. Pertama, Anda harus mengaktifkan hook kode dialog kapan saja dalam percakapan. Kedua, Anda harus mengatur langkah berikutnya dalam percakapan untuk menggunakan hook kode dialog.

Gambar berikut menunjukkan kode dialog hook diaktifkan.

![\[Menunjukkan bahwa hook kode respons bersyarat aktif.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/code-hook-active.png)


Selanjutnya, atur kode hook sebagai tindakan selanjutnya untuk langkah percakapan. Anda dapat melakukan ini dengan mengonfigurasi langkah berikutnya dalam percakapan ke hook kode dialog Invoke. Gambar berikut menunjukkan cabang bersyarat di mana memanggil hook kode dialog adalah langkah berikutnya untuk jalur default percakapan.

![\[Percabangan bersyarat menunjukkan kait kode sebagai langkah selanjutnya dalam percakapan.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/code-hook-choose.png)


Saat kait kode aktif, Anda dapat mengatur tiga respons untuk kembali ke pengguna:
+ **Sukses** - Dikirim ketika fungsi Lambda selesai dengan sukses.
+ **Kegagalan** - Dikirim jika ada masalah dengan menjalankan fungsi Lambda, atau fungsi Lambda mengembalikan nilai. `intent.state` `Failed`
+ **Timeout** - Dikirim jika fungsi Lambda tidak selesai dalam periode batas waktu yang dikonfigurasi.

![\[Diagram alur yang menunjukkan opsi yang tersedia untuk pesan setelah fungsi Lambda berjalan.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/conditional-code-hook.png)


Pilih **kait kode dialog Lambda** dan kemudian pilih **Opsi lanjutan untuk melihat tiga opsi** respons yang sesuai dengan pemanggilan fungsi Lambda. Anda dapat menetapkan nilai, mengonfigurasi langkah berikutnya, dan menerapkan kondisi yang sesuai dengan setiap respons untuk merancang alur percakapan. Dengan tidak adanya kondisi atau langkah eksplisit berikutnya, Amazon Lex V2 memutuskan langkah selanjutnya berdasarkan keadaan percakapan saat ini. 

Pada halaman **Opsi lanjutan** Anda juga dapat memilih untuk mengaktifkan atau menonaktifkan pemanggilan fungsi Lambda Anda. Ketika fungsi diaktifkan, hook kode dialog dipanggil dengan pemanggilan Lambda, diikuti oleh pesan sukses, kegagalan atau batas waktu berdasarkan hasil pemanggilan Lambda. Ketika fungsi dinonaktifkan, Amazon Lex V2 tidak menjalankan fungsi Lambda dan melanjutkan seolah-olah hook kode dialog berhasil.

Anda juga dapat mengatur label pemanggilan yang dikirim ke fungsi Lambda saat dipanggil oleh pesan ini. Anda dapat menggunakan ini untuk membantu mengidentifikasi bagian fungsi Lambda Anda untuk dijalankan.

**catatan**  
Pada 17 Agustus 2022, Amazon Lex V2 merilis perubahan pada cara percakapan dikelola dengan pengguna. Perubahan ini memberi Anda kontrol lebih besar atas jalur yang diambil pengguna melalui percakapan. Untuk informasi selengkapnya, lihat [Perubahan alur percakapan di Amazon Lex V2](understanding-new-flows.md). Bot yang dibuat sebelum 17 Agustus 2022 tidak mendukung pesan kait kode dialog, menyetel nilai, mengonfigurasi langkah selanjutnya, dan menambahkan kondisi.

# Menggunakan pembangun percakapan Visual
<a name="visual-conversation-builder"></a>

Pembuat percakapan visual adalah pembuat percakapan seret dan lepas untuk merancang dan memvisualisasikan jalur percakapan dengan mudah dengan menggunakan maksud dalam lingkungan visual yang kaya.

**Untuk mengakses pembuat percakapan visual**

1. Di konsol Amazon Lex V2, pilih bot dan pilih **Maksud** dari panel navigasi kiri.

1. Buka editor maksud dengan salah satu cara berikut:
   + Pilih **Tambahkan maksud** di sudut kanan atas bagian **Intent**, lalu pilih untuk menambahkan maksud kosong atau intent bawaan.
   + Pilih nama maksud dari bagian **Intent.**

1. Di editor maksud, pilih **Pembuat visual** di panel di bagian bawah layar untuk mengakses pembangun percakapan Visual.

1. Untuk kembali ke antarmuka editor intent menu, pilih **Editor**.

![\[Contoh alur percakapan dengan pembuat percakapan visual.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/vcb-sample.png)


Pembuat percakapan visual menawarkan antarmuka pengguna yang lebih intuitif dengan kemampuan untuk memvisualisasikan dan memodifikasi alur percakapan. Dengan menyeret dan menjatuhkan blok, Anda dapat memperluas alur yang ada atau menyusun ulang langkah-langkah percakapan. Anda dapat mengembangkan alur percakapan dengan percabangan yang kompleks tanpa menulis kode Lambda apa pun.

Perubahan ini membantu memisahkan desain alur percakapan dari logika bisnis lain di Lambda. Pembuat percakapan visual dapat digunakan bersama dengan editor maksud yang ada dan dapat digunakan untuk membangun alur percakapan. Namun, disarankan untuk menggunakan tampilan editor visual untuk alur percakapan yang lebih kompleks.

Saat Anda menyimpan intent, Amazon Lex V2 dapat menyambungkan intent secara otomatis ketika menentukan bahwa ada koneksi yang tidak terjawab, Amazon Lex V2 menyarankan koneksi, atau Anda dapat memilih koneksi Anda sendiri untuk blok tersebut.


| Tindakan | Contoh | 
| --- | --- | 
|  Menambahkan blok ke ruang kerja  |  ![\[Menambahkan blok ke ruang kerja\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/vcb-addblock.gif)  | 
|  Membuat koneksi antar blok  |  ![\[Membuat koneksi antar blok\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/vcb-connectionblock.gif)  | 
|  Membuka panel konfigurasi pada blok  |  ![\[Buka panel konfigurasi blok\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/vcb-openpanelblock.gif)  | 
|  Zoom agar pas  |  ![\[Zoom agar pas\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/vcb-zoomtofit.gif)  | 
|  Menghapus blok dari alur percakapan  |  ![\[Menghapus blok dari alur percakapan\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/vcb-deleteblock.gif)  | 
|  Bersihkan ruang kerja secara otomatis  |  ![\[Bersihkan ruang kerja secara otomatis\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/vcb-autoclean.gif)  | 

**Terminologi:**

**Blok** — Unit bangunan dasar dari alur percakapan. Setiap blok memiliki fungsi khusus untuk menangani kasus penggunaan percakapan yang berbeda.

**Port** — Setiap blok berisi port, yang dapat digunakan untuk menghubungkan satu blok ke blok lainnya. Blok dapat berisi port input dan port output. Setiap port output mewakili variasi fungsional tertentu dari blok (seperti kesalahan, batas waktu, atau keberhasilan).

**Edge** — Edge adalah koneksi antara port output dari satu blok ke port input blok lain. Ini adalah bagian dari cabang dalam alur percakapan.

**Alur percakapan** — Satu set blok yang dihubungkan oleh tepi yang menggambarkan interaksi tingkat maksud dengan pelanggan. 

**Blok**

Blok adalah blok bangunan dari desain alur percakapan. Mereka mewakili status yang berbeda dalam maksud, yang mencakup dari awal maksud, input pengguna, hingga penutupan.

Setiap blok memiliki titik masuk dan satu atau banyak titik keluar berdasarkan jenis blok. Setiap titik keluar dapat dikonfigurasi dengan pesan yang sesuai saat percakapan berlangsung melalui titik keluar. Untuk blok dengan beberapa titik keluar, titik keluar berhubungan dengan status yang sesuai dengan node. Untuk node kondisi, titik keluar mewakili kondisi yang berbeda.

Setiap blok memiliki panel konfigurasi, yang terbuka dengan mengklik ikon **Edit** di sudut kanan atas blok. Panel konfigurasi berisi bidang terperinci yang dapat dikonfigurasi agar sesuai dengan setiap blok.

Permintaan bot dan pesan dapat dikonfigurasi langsung pada node dengan menyeret blok baru, atau mereka dapat dimodifikasi dalam panel kanan, bersama dengan atribut lain dari blok.

**Jenis blok** — Berikut adalah jenis blok yang dapat Anda gunakan dengan pembuat percakapan visual.


| Jenis Blok | Blokir | 
| --- | --- | 
|  **Mulai** — Akar atau blok pertama dari alur percakapan. Blok ini juga dapat dikonfigurasi sedemikian rupa sehingga bot dapat mengirim respons awal (pesan maksud telah dikenali). Untuk informasi selengkapnya, lihat [Respon awal](intent-initial.md).  |  ![\[Blok awal di pembuat percakapan visual\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/vcb-start.png)  | 
|  **Dapatkan nilai slot** — Blok ini mencoba memperoleh nilai untuk satu slot. Blok ini memiliki pengaturan untuk menunggu respons pelanggan terhadap prompt elicitation slot. Untuk informasi selengkapnya, lihat [Slot](intent-slots.md).  |  ![\[Blok nilai slot get di pembuat percakapan visual\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/vcb-getslotvalue.png)  | 
|  **Kondisi** - Blok ini berisi kondisional. Ini berisi hingga 4 cabang khusus (dengan kondisi) dan satu cabang default. Untuk informasi selengkapnya, lihat [Tambahkan kondisi ke percakapan cabang](paths-branching.md).  |  ![\[Blok kondisi di pembuat percakapan visual\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/vcb-condition.png)  | 
|  **Kait kode dialog** - Blok ini menangani pemanggilan fungsi dialog Lambda. Blok ini berisi respons bot berdasarkan dialog fungsi Lambda yang berhasil, gagal, atau habis waktu. Untuk informasi selengkapnya, lihat [Memanggil hook kode dialog](paths-code-hook.md).  |  ![\[Blok pengait kode di pembuat percakapan visual\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/vcb-codehook.png)  | 
|  **Konfirmasi** — Blok ini menanyakan pelanggan sebelum memenuhi maksud. Ini berisi respons bot berdasarkan pelanggan yang mengatakan ya atau tidak pada prompt konfirmasi. Untuk informasi selengkapnya, lihat [Konfirmasi](intent-confirm.md).  |  ![\[Blok konfirmasi di pembuat percakapan visual\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/vcb-confirmation.png)  | 
|  **Pemenuhan** — Blok ini menangani pemenuhan niat, biasanya setelah elisitasi slot. Ini dapat dikonfigurasi untuk memanggil fungsi Lambda, serta merespons dengan pesan, jika pemenuhan berhasil atau gagal. Untuk informasi selengkapnya, lihat [Pemenuhan](intent-fulfillment.md).  |  ![\[Blok pemenuhan di pembuat percakapan visual\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/vcb-fulfillment.png)  | 
|  **Respons penutupan** — Blok ini memungkinkan bot untuk merespons dengan pesan sebelum mengakhiri percakapan. Untuk informasi selengkapnya, lihat [Tanggapan penutupan](intent-closing.md).  |  ![\[Blok penutup di pembuat percakapan visual\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/vcb-closing.png)  | 
|  **Akhiri percakapan** — Blok ini menunjukkan akhir alur percakapan.  |  ![\[Blok akhir di pembuat percakapan visual\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/vcb-end.png)  | 
|  **Tunggu masukan pengguna** — Blok ini dapat digunakan untuk menangkap input dari pelanggan dan beralih ke maksud lain berdasarkan ucapan.  |  ![\[Blok tunggu di pembuat percakapan visual\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/vcb-wait.png)  | 
|  **Pergi ke intent** — Blok ini dapat digunakan untuk pergi ke maksud baru, atau untuk secara langsung mendapatkan slot tertentu dari maksud itu.  |  ![\[Buka blok maksud di pembuat percakapan visual\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/vcb-gotointent.png)  | 

**Jenis port**

Semua blok berisi satu port input, yang digunakan untuk menghubungkan blok induknya. Percakapan hanya dapat mengalir ke port input blok tertentu dari port output blok induknya. Namun, blok dapat berisi nol, satu, atau banyak port output. Blok tanpa port output menandakan akhir alur percakapan di intent saat ini (`GoToIntent`,`EndConversation`,`WaitForUserInput`). 

**Aturan desain niat:**
+ Semua aliran dalam maksud dimulai dengan blok awal.
+ Pesan yang sesuai dengan setiap titik keluar bersifat opsional.
+ Anda dapat mengonfigurasi blok untuk menetapkan nilai yang sesuai dengan setiap titik keluar di panel konfigurasi.
+ Hanya satu blok awal, konfirmasi, pemenuhan, dan penutupan yang dapat ada dalam satu aliran dalam suatu maksud. Beberapa kondisi, kait kode dialog, dapatkan nilai slot, akhiri percakapan, transfer, dan tunggu blok input pengguna mungkin ada.
+ Blok kondisi tidak dapat memiliki koneksi langsung ke blok kondisi. Hal yang sama berlaku untuk hook kode dialog.
+ Aliran melingkar diperbolehkan tiga blok, tetapi konektor masuk ke Start Intent tidak diperbolehkan.
+ Slot opsional tidak memiliki konektor masuk atau koneksi keluar dan terutama digunakan untuk menangkap data apa pun yang ada selama elisitasi maksud. Setiap slot lain yang merupakan bagian dari jalur percakapan harus menjadi slot wajib.

Blok:
+ Blok awal harus memiliki tepi keluar.
+ Setiap blok nilai slot get harus memiliki tepi keluar dari port sukses, jika slot diperlukan.
+ Setiap blok kondisi harus memiliki tepi keluar dari setiap cabang jika blok aktif.
+ Blok kondisi tidak dapat memiliki lebih dari satu induk.
+ Blok kondisi aktif harus memiliki tepi yang masuk.
+ Setiap blok hook kode aktif harus memiliki tepi keluar dari setiap port: keberhasilan, kegagalan, dan batas waktu.
+ Blok kait kode aktif harus memiliki tepi yang masuk.
+ Blok konfirmasi aktif harus memiliki tepi yang masuk.
+ Blok pemenuhan aktif harus memiliki tepi yang masuk.
+ Blok penutupan aktif harus memiliki tepi yang masuk.
+ Blok kondisi harus memiliki setidaknya satu cabang non-default.
+ Blok go to intent harus memiliki maksud yang ditentukan.

Tepi:
+ Blok kondisi tidak dapat dihubungkan ke blok kondisi lain.
+ Blok kait kode tidak dapat dihubungkan ke blok kait kode lain.
+ Blok kondisi hanya dapat dihubungkan ke nol atau satu blok kait kode.
+ Koneksi (code hook -> condition -> code hook) tidak valid.
+ Blok pemenuhan tidak dapat memiliki blok kait kode sebagai anak.
+ Blok kondisi, yang merupakan anak dari blok pemenuhan, tidak dapat memiliki anak blok kait kode.
+ Blok penutup tidak dapat memiliki blok kait kode sebagai anak.
+ Blok kondisi yang merupakan anak dari blok penutup tidak dapat memiliki anak blok kait kode.
+ Blok nilai awal, konfirmasi, atau dapatkan slot dapat memiliki tidak lebih dari satu blok kait kode dalam rantai ketergantungannya.

**catatan**  
Pada 17 Agustus 2022, Amazon Lex V2 merilis perubahan pada cara percakapan dikelola dengan pengguna. Perubahan ini memberi Anda kontrol lebih besar atas jalur yang diambil pengguna melalui percakapan. Untuk informasi selengkapnya, lihat [Perubahan alur percakapan di Amazon Lex V2](understanding-new-flows.md). Bot yang dibuat sebelum 17 Agustus 2022 tidak mendukung pesan kait kode dialog, menyetel nilai, mengonfigurasi langkah selanjutnya, dan menambahkan kondisi.

# Maksud bawaan
<a name="built-in-intents"></a>

Untuk tindakan umum, Anda dapat menggunakan pustaka maksud bawaan standar. Untuk membuat intent dari intent bawaan, pilih intent bawaan di konsol, dan beri nama baru. Maksud baru memiliki konfigurasi maksud dasar, seperti contoh ucapan. 

Dalam implementasi saat ini, Anda tidak dapat melakukan hal berikut: 
+ Menambahkan atau menghapus contoh ucapan dari maksud dasar
+ Konfigurasikan slot untuk maksud bawaan

**Untuk menambahkan intent bawaan ke bot**

1. Masuk ke AWS Management Console dan buka konsol Amazon Lex di [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).

1. Pilih bot untuk menambahkan maksud bawaan.

1. Di menu sebelah kiri, pilih bahasa dan kemudian pilih **Maksud.**

1. Pilih **Tambahkan maksud**, lalu pilih **Gunakan maksud bawaan**.

1. Di **Intent bawaan**, pilih intent yang akan digunakan.

1. Beri maksud nama, lalu pilih **Tambah**.

1. Gunakan editor intent untuk mengonfigurasi intent seperti yang diperlukan untuk bot Anda.

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

**catatan**  
Sebelum Anda dapat memanfaatkan fitur AI generatif, Anda harus memenuhi prasyarat berikut  
Untuk informasi tentang harga untuk menggunakan Amazon Bedrock, lihat harga [Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/).
Aktifkan kemampuan AI generatif untuk lokal bot Anda. Untuk melakukannya, ikuti langkah-langkah di[Optimalkan pembuatan dan kinerja bot Lex V2 dengan menggunakan AI generatif](generative-features.md). 

Mengaktifkan Agen Amazon Bedrock yang ditentukan dalam maksud untuk menanggapi permintaan pelanggan dan mengaktifkan alur kerja agen untuk mencapai tugas yang ditentukan. Fitur ini tersedia di semua lokal yang didukung Amazon Lex V2 dan semua wilayah komersial di mana Amazon Lex V2 dan Amazon Bedrock Agents hadir. 

Jika maksud ini mengesampingkan`FallbackIntent`, maksud diaktifkan ketika ucapan tidak diklasifikasikan ke dalam maksud lain yang ada di bot, jika tidak maka hanya diaktifkan ketika ucapan diklasifikasikan ke dalam maksud ini. Penting untuk dicatat bahwa maksud ini tidak akan diaktifkan untuk ucapan yang terlewat saat memunculkan nilai slot. 

Setelah dikenali oleh bot Amazon Lex V2 Anda`AMAZON.BedrockAgentIntent`, mengaktifkan yang ditentukan `BedrockAgent` atau `BedrockKnowledgeBase` untuk menanggapi pelanggan. Jika Anda menggunakan Agen Bedrock Amazon, percakapan tetap ada `BedrockAgentIntent` dan permintaan pengguna diteruskan ke Agen, hingga Agen Bedrock Amazon menentukan bahwa percakapan ditandai. `FINISH` Hanya setelah itu, Amazon Lex V2 mengasumsikan kontrol percakapan dan mematuhi langkah selanjutnya yang ditentukan dalam. `AMAZON.BedrockAgentIntent`

Menanggapi pertanyaan pelanggan dengan menggunakan Agen dan Pangkalan Pengetahuan Amazon Bedrock untuk menjawab pertanyaan pelanggan dan memberikan tanggapan terperinci.

**Awas**  
Anda tidak dapat menggunakan ucapan `AMAZON.BedrockAgentIntent` tanpa sampel, `AMAZON.QnAIntent` tanpa ucapan sampel dan `AMAZON.KendraSearchIntent` di lokal bot yang sama.

Jika Anda memilih maksud ini, Anda mengonfigurasi bidang berikut dan kemudian pilih Tambah untuk menambahkan maksud.
+ Amazon Bedrock Agent Id - Pengidentifikasi Agen Batuan Dasar Amazon. Pilih Agen Bedrock yang ingin Anda gunakan. 
+ Amazon Bedrock Agent Alias Id - Pengidentifikasi Alias dari Agen Batuan Dasar Amazon.

**penting**  
Saat membuat Agen Bedrock Amazon untuk digunakan dengan Amazon Lex V2, verifikasi bahwa **Input Pengguna** di bawah **Pengaturan Tambahan** adalah`ENABLED`. Pengaturan ini sangat penting untuk memungkinkan Agen mengajukan pertanyaan klarifikasi atau tindak lanjut, dan memungkinkan Amazon Lex V2 untuk mendelegasikan kembali ke Agen untuk menyelesaikan tugas yang sesuai.

(Opsional) Anda juga dapat menambahkan BedrockAgentIntent dengan opsi ini:
+ Model Amazon Bedrock - Pilih penyedia dan model pondasi yang akan digunakan untuk maksud ini. Saat ini, beberapa model Anthropic Claude didukung. 
+ Basis Pengetahuan Amazon Bedrock - Jika Anda memilih opsi ini, tentukan ID Basis Pengetahuan Amazon Bedrock. Anda dapat menemukan ID dengan memeriksa halaman detail Pangkalan Pengetahuan Amazon Bedrock di konsol, atau dengan mengirimkan `GetKnowledgeBase` permintaan.

Tanggapan dari BedrockAgentIntent akan disimpan ke dalam sesi dan meminta atribut seperti yang ditunjukkan di bawah ini:
+ `x-amz-lex:bedrock-agent-search-response`— Tanggapan dari Amazon Bedrock Agent untuk pertanyaan atau ucapan.
+ `x-amz-lex:bedrock-knowledge-base-search-response-source`— Menunjuk ke dokumen, atau daftar dokumen, yang digunakan untuk menghasilkan respons jika menggunakan konfigurasi Pangkalan Pengetahuan Amazon Bedrock.
+ `x-amz-lex:bedrock-agent-action-group-invocation-input`- Objek yang berisi nilai masukan yang dikumpulkan oleh kelompok aksi agen. Untuk informasi selengkapnya tentang grup aksi agen, lihat ActionGroupInvocationInput.
+ `x-amz-lex:bedrock-agent-knowledge-base-lookup-input`- Objek yang berisi rincian terkait pencarian Amazon Bedrock Knowledge Base.
+ `x-amz-lex:bedrock-agent-agent-collaborator-details`— Objek yang berisi rincian input dan output dari sub agen yang dipanggil sebagai bagian dari pemanggilan kolaborasi multi-agen.

Untuk informasi selengkapnya, lihat [Menggunakan BedrockAgentIntent untuk menggunakan Agen Batuan Dasar di Amazon Lex](https://docs.aws.amazon.com/lexv2/latest/dg/bedrock-agent-intent.html).

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

Menanggapi kata dan frasa yang menunjukkan pengguna ingin membatalkan interaksi saat ini. Aplikasi Anda dapat menggunakan intent ini untuk menghapus nilai jenis slot dan atribut lainnya sebelum mengakhiri interaksi dengan pengguna.

Ucapan umum:
+ membatalkan
+ tidak pernah keberatan
+ lupakan saja

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

*Jika input pengguna ke intent tidak seperti yang diharapkan bot, Anda dapat mengonfigurasi Amazon Lex V2 untuk memanggil maksud fallback.* Misalnya, jika input pengguna “Saya ingin memesan permen” tidak cocok dengan maksud di `OrderFlowers` bot Anda, Amazon Lex V2 memanggil maksud fallback untuk menangani respons.

Jenis `AMAZON.FallbackIntent` intent bawaan ditambahkan ke bot Anda secara otomatis saat Anda membuat bot menggunakan konsol atau saat Anda menambahkan lokal ke bot menggunakan operasi. [CreateBotLocale](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateBotLocale.html) 

Memanggil maksud fallback menggunakan dua langkah. Pada langkah pertama maksud fallback dicocokkan berdasarkan input dari pengguna. Ketika maksud fallback dicocokkan, cara bot berperilaku bergantung pada jumlah percobaan ulang yang dikonfigurasi untuk prompt. 

Amazon Lex V2 cocok dengan maksud mundur dalam situasi ini: 
+ Input pengguna ke intent tidak cocok dengan input yang diharapkan bot
+ Input audio adalah noise, atau input teks tidak dikenali sebagai kata-kata.
+ Input pengguna bersifat ambigu dan Amazon Lex V2 tidak dapat menentukan maksud mana yang akan dipanggil.

Maksud fallback dipanggil saat:
+ Intent tidak mengenali input pengguna sebagai nilai slot setelah jumlah percobaan yang dikonfigurasi.
+ Intent tidak mengenali input pengguna sebagai respons terhadap prompt konfirmasi setelah jumlah percobaan yang dikonfigurasi.

Anda tidak dapat menambahkan yang berikut ini ke maksud fallback:
+ Ucapan
+ Slot
+ Prompt konfirmasi

## Menggunakan Fungsi Lambda dengan Maksud Fallback
<a name="invoke-fallback"></a>

Ketika maksud fallback dipanggil, respons bergantung pada pengaturan `fulfillmentCodeHook` parameter ke operasi. [CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html) Bot melakukan salah satu hal berikut:
+ Mengembalikan informasi maksud ke aplikasi klien.
+ Memanggil validasi alias dan pemenuhan fungsi Lambda. Ini memanggil fungsi dengan variabel sesi yang diatur untuk sesi.

Untuk informasi selengkapnya tentang menyetel respons saat maksud fallback dipanggil, lihat `fulfillmentCodeHook` parameter operasi. [CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html) 

Jika Anda menggunakan fungsi Lambda dengan maksud fallback, Anda dapat menggunakan fungsi ini untuk memanggil maksud lain atau untuk melakukan beberapa bentuk komunikasi dengan pengguna, seperti mengumpulkan nomor panggilan balik atau membuka sesi dengan perwakilan layanan pelanggan.

Maksud fallback dapat dipanggil beberapa kali dalam sesi yang sama. Misalnya, fungsi Lambda Anda menggunakan tindakan `ElicitIntent` dialog untuk meminta pengguna untuk maksud yang berbeda. Jika Amazon Lex V2 tidak dapat menyimpulkan maksud pengguna setelah jumlah percobaan yang dikonfigurasi, Amazon Lex V2 akan memanggil maksud fallback lagi. Ini juga memanggil maksud fallback ketika pengguna tidak merespons dengan nilai slot yang valid setelah jumlah percobaan yang dikonfigurasi.

Anda dapat mengonfigurasi fungsi Lambda untuk melacak berapa kali intent fallback dipanggil menggunakan variabel sesi. Fungsi Lambda Anda dapat mengambil tindakan yang berbeda jika dipanggil lebih banyak dari ambang batas yang Anda tetapkan dalam fungsi Lambda Anda. Untuk informasi selengkapnya tentang variabel sesi, lihat[Mengatur atribut sesi untuk bot Lex V2 Anda](context-mgmt-session-attribs.md).

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

Menanggapi kata atau frasa yang menunjukkan pengguna membutuhkan bantuan saat berinteraksi dengan bot Anda. Ketika intent ini dipanggil, Anda dapat mengonfigurasi fungsi atau aplikasi Lambda Anda untuk memberikan informasi tentang kemampuan bot Anda, mengajukan pertanyaan lanjutan tentang area bantuan, atau menyerahkan interaksi ke agen manusia. 

Ucapan umum:
+ bantuan
+ tolong aku
+ dapatkah Anda membantu saya

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

Untuk mencari dokumen yang telah Anda indeks dengan Amazon Kendra, gunakan intent. `AMAZON.KendraSearchIntent` Jika Amazon Lex V2 tidak dapat menentukan tindakan selanjutnya dalam percakapan dengan pengguna, Amazon Lex V2 akan memicu maksud pencarian.

`AMAZON.KendraSearchIntent`Ini hanya tersedia di wilayah Inggris (AS) (en-AS) dan di Wilayah AS Timur (Virginia N.), AS Barat (Oregon) dan Eropa (Irlandia).

Amazon Kendra adalah layanan machine-learning-based pencarian yang mengindeks dokumen bahasa alami seperti dokumen PDF atau file Microsoft Word. Ini dapat mencari dokumen yang diindeks dan mengembalikan jenis tanggapan berikut ke pertanyaan:
+ Jawaban 
+ Entri dari FAQ yang mungkin menjawab pertanyaan
+ Dokumen yang terkait dengan pertanyaan

Untuk contoh menggunakan`AMAZON.KendraSearchIntent`, lihat[Contoh: Membuat Bot FAQ untuk Indeks Amazon Kendra](faq-bot-kendra-search.md).

Jika Anda mengonfigurasi `AMAZON.KendraSearchIntent` intent untuk bot Anda, Amazon Lex V2 akan memanggil intent kapan pun intent tidak dapat menentukan ucapan pengguna untuk maksud. Jika tidak ada tanggapan dari Amazon Kendra, percakapan berlanjut seperti yang dikonfigurasi di bot.

**catatan**  
 Amazon Lex V2 saat ini tidak mendukung elisitasi slot `AMAZON.KendraSearchIntent` selama. Jika Amazon Lex V2 tidak dapat menentukan ucapan pengguna untuk slot, itu memanggil file. `AMAZON.FallbackIntent` 

Saat Anda menggunakan `AMAZON.KendraSearchIntent` with `AMAZON.FallbackIntent` di bot yang sama, Amazon Lex V2 menggunakan intent sebagai berikut:

1. Amazon Lex V2 menyebut`AMAZON.KendraSearchIntent`. Maksudnya menyebut operasi Amazon `Query` Kendra.

1. Jika Amazon Kendra mengembalikan respons, Amazon Lex V2 menampilkan hasilnya kepada pengguna.

1. Jika tidak ada tanggapan dari Amazon Kendra, Amazon Lex V2 meminta kembali pengguna. Tindakan selanjutnya tergantung pada respons dari pengguna.
   + Jika respons dari pengguna berisi ucapan yang dikenali Amazon Lex V2, seperti mengisi nilai slot atau mengonfirmasi maksud, percakapan dengan pengguna dilanjutkan seperti yang dikonfigurasi untuk bot.
   + Jika respons dari pengguna tidak berisi ucapan yang dikenali Amazon Lex V2, Amazon Lex V2 akan melakukan panggilan lain ke operasi tersebut. `Query`

1. Jika tidak ada respons setelah jumlah percobaan ulang yang dikonfigurasi, Amazon Lex V2 memanggil `AMAZON.FallbackIntent` dan mengakhiri percakapan dengan pengguna.

Ada tiga cara untuk menggunakan `AMAZON.KendraSearchIntent` untuk membuat permintaan ke Amazon Kendra:
+ Biarkan maksud pencarian membuat permintaan untuk Anda. Amazon Lex V2 menyebut Amazon Kendra dengan ucapan pengguna sebagai string pencarian. Saat membuat intent, Anda dapat menentukan string filter kueri yang membatasi jumlah respons yang dikembalikan Amazon Kendra. Amazon Lex V2 menggunakan filter dalam permintaan kueri.
+ Tambahkan parameter kueri tambahan ke permintaan untuk mempersempit hasil pencarian menggunakan fungsi Lambda Anda. Anda menambahkan `kendraQueryFilterString` bidang yang berisi parameter kueri Amazon Kendra ke tindakan `delegate` dialog. Saat Anda menambahkan parameter kueri ke permintaan dengan fungsi Lambda, parameter tersebut lebih diutamakan daripada filter kueri yang Anda tentukan saat Anda membuat maksud.
+ Buat kueri baru menggunakan fungsi Lambda. Anda dapat membuat permintaan kueri Amazon Kendra lengkap yang dikirimkan Amazon Lex V2. Anda menentukan kueri di `kendraQueryRequestPayload` bidang dalam tindakan `delegate` dialog. `kendraQueryRequestPayload`Lapangan lebih diutamakan di atas lapangan. `kendraQueryFilterString`

Untuk menentukan `queryFilterString` parameter saat Anda membuat bot, atau untuk menentukan `kendraQueryFilterString` bidang saat Anda memanggil `delegate` tindakan dalam dialog fungsi Lambda, Anda menentukan string yang digunakan sebagai filter atribut untuk kueri Amazon Kendra. Jika string bukan filter atribut yang valid, Anda akan mendapatkan `InvalidBotConfigException` pengecualian saat runtime. Untuk informasi selengkapnya tentang filter atribut, lihat [Menggunakan atribut dokumen untuk memfilter kueri](https://docs.aws.amazon.com/kendra/latest/dg/filtering.html#search-filtering) di Panduan Pengembang *Amazon Kendra*.

Untuk memiliki kontrol atas kueri yang dikirimkan Amazon Lex V2 ke Amazon Kendra, Anda dapat menentukan kueri di `kendraQueryRequestPayload` bidang di fungsi Lambda Anda. Jika kueri tidak valid, Amazon Lex V2 mengembalikan `InvalidLambdaResponseException` pengecualian. Untuk informasi selengkapnya, lihat [Operasi kueri](https://docs.aws.amazon.com/kendra/latest/dg/API_Query.html) di Panduan *Pengembang Amazon Kendra*.

Untuk contoh cara menggunakan`AMAZON.KendraSearchIntent`, lihat[Contoh: Membuat Bot FAQ untuk Indeks Amazon Kendra](faq-bot-kendra-search.md).

## Kebijakan IAM untuk Pencarian Amazon Kendra
<a name="kendra-search-iam"></a>

Untuk menggunakan `AMAZON.KendraSearchIntent` intent, Anda harus menggunakan peran yang menyediakan kebijakan AWS Identity and Access Management (IAM) yang memungkinkan Amazon Lex V2 untuk mengambil peran runtime yang memiliki izin untuk memanggil maksud Amazon Kendra. `Query` Pengaturan IAM yang Anda gunakan bergantung pada apakah Anda membuat `AMAZON.KendraSearchIntent` menggunakan konsol Amazon Lex V2, atau menggunakan AWS SDK atau ( AWS Command Line Interface AWS CLI). Saat menggunakan konsol, Anda dapat memilih antara menambahkan izin untuk memanggil Amazon Kendra ke peran terkait layanan Amazon Lex V2 atau menggunakan peran khusus untuk memanggil operasi Amazon Kendra. `Query` Saat Anda menggunakan AWS CLI atau SDK untuk membuat intent, Anda harus menggunakan peran khusus untuk memanggil operasi. `Query`

### Melampirkan Izin
<a name="kendra-iam-attach"></a>

Anda dapat menggunakan konsol untuk melampirkan izin untuk mengakses operasi Amazon `Query` Kendra ke peran default Amazon Lex V2 terkait layanan. Saat melampirkan izin ke peran terkait layanan, Anda tidak perlu membuat dan mengelola peran runtime secara khusus untuk terhubung ke indeks Amazon Kendra.

Pengguna, peran, atau grup yang Anda gunakan untuk mengakses konsol Amazon Lex V2 harus memiliki izin untuk mengelola kebijakan peran. Lampirkan kebijakan IAM berikut ke peran akses konsol. Saat Anda memberikan izin ini, peran tersebut memiliki izin untuk mengubah kebijakan peran terkait layanan yang ada. 

------
#### [ 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": "*"
    }
]
}
```

------

### Menentukan Peran
<a name="kendra-iam-role"></a>

Anda dapat menggunakan konsol, AWS CLI, atau API untuk menentukan peran runtime yang akan digunakan saat memanggil operasi Amazon Kendra. `Query` 

Pengguna, peran, atau grup yang Anda gunakan untuk menentukan peran runtime harus memiliki `iam:PassRole` izin. Kebijakan berikut mendefinisikan izin. Anda dapat menggunakan kunci konteks `iam:AssociatedResourceArn` dan `iam:PassedToService` kondisi untuk membatasi cakupan izin lebih lanjut. Untuk informasi selengkapnya, lihat [IAM dan AWS STS Condition Context Keys](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html) di *Panduan Pengguna AWS Identity and Access Management*.

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

****  

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

------

Peran runtime yang perlu digunakan Amazon Lex V2 untuk memanggil Amazon Kendra harus memiliki `kendra:Query` izin. Saat Anda menggunakan peran IAM yang ada untuk izin memanggil operasi Amazon `Query` Kendra, peran tersebut harus memiliki kebijakan berikut yang dilampirkan.

Anda dapat menggunakan konsol IAM, IAM API, atau AWS CLI untuk membuat kebijakan dan melampirkannya ke peran. Petunjuk ini menggunakan AWS CLI untuk membuat peran dan kebijakan.

**catatan**  
Kode berikut diformat untuk Linux dan macOS. Untuk Windows, ganti karakter kelanjutan baris Linux (\$1) dengan tanda sisipan (^).

**Untuk menambahkan izin operasi Kueri ke peran**

1. Buat dokumen yang disebut **KendraQueryPolicy.json** di direktori saat ini, tambahkan kode berikut ke dalamnya, dan simpan

1. Di AWS CLI, jalankan perintah berikut untuk membuat kebijakan IAM untuk menjalankan operasi Amazon Kendra. `Query`

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

1. Lampirkan kebijakan ke peran IAM yang Anda gunakan untuk memanggil `Query` operasi.

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

Anda dapat memilih untuk memperbarui peran terkait layanan Amazon Lex V2 atau menggunakan peran yang Anda buat saat membuat `AMAZON.KendraSearchIntent` untuk bot Anda. Prosedur berikut menunjukkan bagaimana memilih peran IAM untuk digunakan.

**Untuk menentukan peran runtime untuk AMAZON.KendraSearchIntent**

1. Masuk ke AWS Management Console dan buka konsol Amazon Lex di [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).

1. Pilih bot yang ingin Anda tambahkan. `AMAZON.KendraSearchIntent`

1. Pilih plus (\$1) di sebelah **Intent.**

1. Di **Tambah maksud**, pilih **Cari maksud yang ada**.

1. Di **Maksud pencarian**, masukkan **AMAZON.KendraSearchIntent** lalu pilih **Tambah**.

1. **Di **Salin maksud bawaan**, masukkan nama untuk maksud, seperti**KendraSearchIntent**, lalu pilih Tambah.**

1. Buka bagian **kueri Amazon Kendra**.

1. Untuk **peran IAM** pilih salah satu opsi berikut:
   + Untuk memperbarui peran terkait layanan Amazon Lex V2 untuk mengaktifkan bot Anda menanyakan indeks Amazon Kendra, pilih Tambahkan izin **Amazon** Kendra.
   + Untuk menggunakan peran yang memiliki izin untuk memanggil `Query` operasi Amazon Kendra, pilih **Gunakan peran yang ada**.

## Menggunakan Atribut Permintaan dan Sesi sebagai Filter
<a name="kendra-search-filter"></a>

Untuk memfilter respons dari Amazon Kendra ke item yang terkait dengan percakapan saat ini, gunakan atribut sesi dan permintaan sebagai filter dengan menambahkan `queryFilterString` parameter saat Anda membuat bot. Anda menentukan placeholder untuk atribut saat membuat intent, lalu Amazon Lex V2 mengganti nilai sebelum memanggil Amazon Kendra. Untuk informasi selengkapnya tentang atribut permintaan, lihat[Mengatur atribut permintaan untuk bot Lex V2 Anda](context-mgmt-request-attribs.md). Untuk informasi selengkapnya tentang atribut sesi, lihat[Mengatur atribut sesi untuk bot Lex V2 Anda](context-mgmt-session-attribs.md).

Berikut ini adalah contoh `queryFilterString` parameter yang menggunakan string untuk memfilter kueri Amazon Kendra.

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

Berikut ini adalah contoh `queryFilterString` parameter yang menggunakan atribut sesi dipanggil `"SourceURI"` untuk memfilter kueri Amazon Kendra.

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

Berikut ini adalah contoh `queryFilterString` parameter yang menggunakan atribut permintaan dipanggil `"DepartmentName"` untuk memfilter kueri Amazon Kendra.

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

`AMAZON.KendraSearchInteng`Filter menggunakan format yang sama dengan filter pencarian Amazon Kendra. Untuk informasi selengkapnya, lihat [Menggunakan atribut dokumen untuk memfilter hasil penelusuran](https://docs.aws.amazon.com/kendra/latest/dg/filtering.html#search-filtering) di *panduan pengembang Amazon Kendra*.

String filter kueri yang digunakan dengan huruf kecil `AMAZON.KendraSearchIntent` harus menggunakan huruf kecil untuk huruf pertama dari setiap filter. Misalnya, berikut ini adalah filter kueri yang valid untuk file`AMAZON.KendraSearchIntent`.

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

## Menggunakan Respon Pencarian
<a name="kendra-search-response"></a>

Amazon Kendra mengembalikan respons ke pencarian sebagai tanggapan dari pernyataan niat. `IntentClosingSetting` Maksud harus memiliki `closingResponse` pernyataan kecuali fungsi Lambda menghasilkan pesan respons penutup.

Amazon Kendra memiliki lima jenis tanggapan. 
+ Dua tanggapan berikut memerlukan FAQ yang akan disiapkan untuk indeks Amazon Kendra Anda. Untuk detail selengkapnya, lihat [Menambahkan pertanyaan dan jawaban langsung ke indeks](https://docs.aws.amazon.com/kendra/latest/dg/in-creating-faq.html).
  +  `x-amz-lex:kendra-search-response-question_answer-question-<N>`— Pertanyaan dari FAQ yang cocok dengan pencarian. 
  +  `x-amz-lex:kendra-search-response-question_answer-answer-<N>`— Jawaban dari FAQ yang cocok dengan pencarian. 
+ Tiga tanggapan berikut memerlukan sumber data yang akan disiapkan untuk indeks Amazon Kendra Anda. Untuk detail selengkapnya, lihat [Membuat sumber data](https://docs.aws.amazon.com/kendra/latest/dg/data-source.html). 
  + `x-amz-lex:kendra-search-response-document-<N>`— Kutipan dari dokumen dalam indeks yang terkait dengan teks ucapan.
  + `x-amz-lex:kendra-search-response-document-link-<N>`— URL dokumen dalam indeks yang terkait dengan teks ucapan.
  + `x-amz-lex:kendra-search-response-answer-<N>`— Kutipan dari dokumen dalam indeks yang menjawab pertanyaan.

Tanggapan dikembalikan dalam `request` atribut. Ada hingga lima tanggapan untuk setiap atribut, bernomor 1 hingga 5. Untuk informasi selengkapnya tentang tanggapan, lihat [Jenis respons](https://docs.aws.amazon.com/kendra/latest/dg/response-types.html) di Panduan *Pengembang Amazon Kendra*. 

`closingResponse`Pernyataan harus memiliki satu atau lebih grup pesan. Setiap grup pesan berisi satu atau beberapa pesan. Setiap pesan dapat berisi satu atau beberapa variabel placeholder yang diganti dengan atribut permintaan dalam respons dari Amazon Kendra. Harus ada setidaknya satu pesan dalam grup pesan di mana semua variabel dalam pesan diganti dengan nilai atribut permintaan dalam respons runtime, atau harus ada pesan dalam grup tanpa variabel placeholder. Atribut permintaan diatur dengan tanda kurung ganda (“((” “))”). Pesan grup pesan berikut cocok dengan respons apa pun dari Amazon Kendra:
+ “Saya menemukan pertanyaan FAQ untuk Anda: ((x-amz-lex: kendra-search-response-question \$1jawaban-pertanyaan-1)), dan jawabannya adalah ((: \$1jawaban-jawab-1))” x-amz-lex kendra-search-response-question
+ “Saya menemukan kutipan dari dokumen yang bermanfaat: ((x-amz-lex: kendra-search-response-document -1))”
+ “Saya pikir jawaban atas pertanyaan Anda adalah ((x-amz-lex: kendra-search-response-answer -1))”

## Menggunakan Fungsi Lambda untuk Mengelola Permintaan dan Respons
<a name="kendra-search-lambda"></a>

`AMAZON.KendraSearchIntent`Maksud dapat menggunakan hook kode dialog dan hook kode pemenuhan untuk mengelola permintaan ke Amazon Kendra dan responsnya. Gunakan fungsi Lambda kait kode dialog saat Anda ingin memodifikasi kueri yang Anda kirim ke Amazon Kendra, dan kode pemenuhan menghubungkan fungsi Lambda saat Anda ingin memodifikasi respons.

### Membuat Query dengan Hook Kode Dialog
<a name="kendra-search-lambda-dialog"></a>

Anda dapat menggunakan hook kode dialog untuk membuat kueri untuk dikirim ke Amazon Kendra. Menggunakan hook kode dialog adalah opsional. Jika Anda tidak menentukan hook kode dialog, Amazon Lex V2 akan membuat kueri dari ucapan pengguna dan menggunakan `queryFilterString` yang Anda berikan saat mengonfigurasi intent, jika Anda memberikannya.

Anda dapat menggunakan dua bidang dalam respons kait kode dialog untuk memodifikasi permintaan ke Amazon Kendra:
+ `kendraQueryFilterString`— Gunakan string ini untuk menentukan filter atribut untuk permintaan Amazon Kendra. Anda dapat memfilter kueri menggunakan salah satu bidang indeks yang ditentukan dalam indeks Anda. Untuk struktur string filter, lihat [Menggunakan atribut dokumen untuk memfilter kueri di Panduan](https://docs.aws.amazon.com/kendra/latest/dg/filtering.html#search-filtering) Pengembang *Amazon Kendra*. Jika string filter yang ditentukan tidak valid, Anda akan mendapatkan `InvalidLambdaResponseException` pengecualian. `kendraQueryFilterString`String mengesampingkan string kueri apa pun yang ditentukan dalam `queryFilterString` konfigurasi untuk maksud.
+ `kendraQueryRequestPayload`— Gunakan string ini untuk menentukan kueri Amazon Kendra. Kueri Anda dapat menggunakan salah satu fitur Amazon Kendra. Jika Anda tidak menentukan kueri yang valid, Anda mendapatkan `InvalidLambdaResponseException` pengecualian. Untuk informasi selengkapnya, lihat [Kueri](https://docs.aws.amazon.com/kendra/latest/dg/API_Query.html) di Panduan *Pengembang Amazon Kendra*.

Setelah Anda membuat filter atau string kueri, Anda mengirim respons ke Amazon Lex V2 dengan `dialogAction` bidang respons yang disetel ke`delegate`. Amazon Lex V2 mengirimkan kueri ke Amazon Kendra dan kemudian mengembalikan respons kueri ke hook kode pemenuhan.

### Menggunakan Hook Kode Pemenuhan untuk Respons
<a name="kendra-search-lambda-fulfillment"></a>

Setelah Amazon Lex V2 mengirimkan kueri ke Amazon Kendra, respons kueri dikembalikan ke fungsi Lambda `AMAZON.KendraSearchIntent` pemenuhan. Acara input ke kait kode berisi respons lengkap dari Amazon Kendra. Data kueri berada dalam struktur yang sama dengan yang dikembalikan oleh operasi Amazon Kendra`Query`. Untuk informasi selengkapnya, lihat [Sintaks respons kueri](https://docs.aws.amazon.com/kendra/latest/dg/API_Query.html#API_Query_ResponseSyntax) di Panduan Pengembang *Amazon Kendra*.

Kait kode pemenuhan adalah opsional. Jika tidak ada, atau jika kait kode tidak mengembalikan pesan dalam respons, Amazon Lex V2 menggunakan `closingResponse` pernyataan untuk tanggapan.

# Contoh: Membuat Bot FAQ untuk Indeks Amazon Kendra
<a name="faq-bot-kendra-search"></a>

Contoh ini membuat bot Amazon Lex V2 yang menggunakan indeks Amazon Kendra untuk memberikan jawaban atas pertanyaan pengguna. Bot FAQ mengelola dialog untuk pengguna. Ini menggunakan `AMAZON.KendraSearchIntent` maksud untuk menanyakan indeks dan menyajikan respons kepada pengguna. Berikut adalah ringkasan tentang bagaimana Anda akan membuat bot FAQ Anda menggunakan indeks Amazon Kendra:

1. Buat bot yang akan berinteraksi dengan pelanggan Anda untuk mendapatkan jawaban dari bot Anda.

1. Buat maksud khusus. Karena `AMAZON.KendraSearchIntent` dan `AMAZON.FallbackIntent` merupakan maksud cadangan, bot Anda memerlukan setidaknya satu maksud lain yang harus berisi setidaknya satu ucapan. Maksud ini memungkinkan bot Anda untuk membangun, tetapi tidak digunakan sebaliknya. Bot FAQ Anda akan berisi setidaknya tiga maksud, seperti pada gambar di bawah ini:   
![\[Bot FAQ Kendra dengan tiga maksud\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/kendra-faqbot/kendra-intents.png)

1. Tambahkan `AMAZON.KendraSearchIntent` intent ke bot Anda dan konfigurasikan agar berfungsi dengan indeks [Amazon Kendra](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html) Anda. 

1. Uji bot dengan membuat kueri dan memverifikasi bahwa hasil dari indeks Amazon Kendra Anda adalah dokumen yang menjawab kueri.

**Prasyarat**

Sebelum Anda dapat menggunakan contoh ini, Anda perlu membuat indeks Amazon Kendra. Untuk informasi selengkapnya, lihat [Memulai konsol Amazon Kendra di Panduan](https://docs.aws.amazon.com/kendra/latest/dg/gs-console.html) Pengembang *Amazon Kendra*. Untuk contoh ini, pilih kumpulan data **sampel (Contoh dokumentasi AWS**) sebagai sumber data Anda.

**Untuk membuat bot FAQ:**

1. Masuk ke AWS Management Console dan buka konsol Amazon Lex di [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).

1. Di panel navigasi, pilih **Bots**. 

1. Pilih **Buat bot**.

   1.  Untuk **metode Creation**, pilih **Create a blank bot**. 

   1.  Di bagian **konfigurasi Bot**, beri bot nama yang menunjukkan tujuannya, seperti**KendraTestBot**, dan deskripsi opsional. Nama harus unik di akun Anda. 

   1.  Di bagian **Izin IAM, pilih Buat peran dengan izin** **Amazon Lex dasar**. Ini akan membuat peran [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) dengan izin yang dibutuhkan Amazon Lex V2 untuk menjalankan bot Anda. 

   1.  Di bagian **Children's Online Privacy Protection Act (COPPA)**, pilih **No**. 

   1.  **Di bagian **batas waktu sesi Idle** dan **Pengaturan lanjutan**, tinggalkan pengaturan default dan pilih Berikutnya.** 

   1.  Sekarang Anda berada di bagian **Tambahkan bahasa ke bot**. Di menu di bawah **Interaksi suara**, pilih **Tidak Ada. Ini hanya aplikasi berbasis teks**. Tinggalkan pengaturan default untuk bidang yang tersisa. 

   1.  Pilih **Selesai**. Amazon Lex V2 membuat bot Anda dan maksud default yang disebut **NewIntent**, dan membawa Anda ke halaman untuk mengonfigurasi maksud ini 

Agar berhasil membangun bot, Anda harus membuat setidaknya satu maksud yang terpisah dari `AMAZON.FallbackIntent` dan. `AMAZON.KendraSearchIntent` Maksud ini diperlukan untuk membangun bot Amazon Lex V2 Anda, tetapi tidak digunakan untuk respons FAQ. Maksud ini harus mengandung setidaknya satu contoh ucapan dan ucapan tersebut tidak boleh berlaku untuk pertanyaan apa pun yang diajukan pelanggan Anda.

**Untuk membuat maksud yang diperlukan:**

1.  Di bagian **Detail maksud**, beri nama maksud, seperti. **RequiredIntent** 

1.  Di bagian **Sample ujaran**, ketikkan ucapan di kotak di sebelah **Tambahkan ucapan**, seperti. **Required utterance** Kemudian pilih **Tambahkan ucapan**. 

1. Pilih **Simpan maksud.**

Buat maksud untuk mencari indeks Amazon Kendra dan pesan respons yang harus dikembalikan.

**Untuk membuat AMAZON. KendraSearchIntent pesan maksud dan respons:**

1.  Pilih **Kembali ke daftar maksud** di panel navigasi untuk kembali ke halaman **Intent untuk bot** Anda. Pilih **Tambah maksud** dan pilih **Gunakan maksud bawaan** dari menu tarik-turun. 

1.  Di kotak yang muncul, pilih menu di bawah **Maksud bawaan**. Masukkan **AMAZON.KendraSearchIntent** di bilah pencarian dan kemudian pilih dari daftar. 

1.  Berikan maksud nama, seperti**KendraSearchIntent**. 

1.  Dari menu tarik-turun **indeks Amazon Kendra**, pilih indeks yang ingin Anda cari. Indeks yang Anda buat di bagian **Prasyarat** harus tersedia. 

1.  Pilih **Tambahkan**. 

1. Di editor maksud, gulir ke bawah ke bagian **Pemenuhan**, pilih panah kanan untuk memperluas bagian, dan tambahkan pesan berikut di kotak di bawah **Pada pemenuhan yang berhasil**: 

   ```
   I found a link to a document that could help you: ((x-amz-lex:kendra-search-response-document-link-1)).
   ```  
![\[Tambahkan respons pemenuhan\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/kendra-faqbot/kendra-fulfillment-response.gif)

    Untuk informasi selengkapnya tentang Respons Penelusuran Amazon Kendra, lihat [Menggunakan Respons Penelusuran](https://docs.aws.amazon.com/lexv2/latest/dg/built-in-intent-kendra-search.html#kendra-search-response). 

1. Pilih **Simpan maksud**, lalu pilih **Build** untuk membangun bot. Saat bot sudah siap, spanduk di bagian atas layar berubah menjadi hijau dan menampilkan pesan sukses. 

Terakhir, gunakan jendela pengujian konsol untuk menguji respons dari bot Anda.

**Untuk menguji bot FAQ Anda:**

1.  Setelah bot berhasil dibangun, pilih **Uji**. 

1.  Masukkan **What is Amazon Kendra?** di jendela uji konsol. Verifikasi bahwa bot merespons dengan tautan. 

1.  Untuk informasi selengkapnya tentang mengonfigurasi`AMAZON.KendraSearchIntent`, lihat [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)dan [KendraConfiguration](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_KendraConfiguration.html). 

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

Menanggapi kata dan frasa yang memungkinkan pengguna untuk menjeda interaksi dengan bot sehingga mereka dapat kembali ke sana nanti. Fungsi atau aplikasi Lambda Anda perlu menyimpan data maksud dalam variabel sesi, atau Anda perlu menggunakan [GetSession](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_GetSession.html)operasi untuk mengambil data maksud saat melanjutkan maksud saat ini.

Ucapan umum:
+ jeda
+ jeda itu

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

**catatan**  
Sebelum Anda dapat memanfaatkan fitur AI generatif, Anda harus memenuhi prasyarat berikut  
Untuk informasi tentang harga untuk menggunakan Amazon Bedrock, lihat harga [Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/).
Aktifkan kemampuan AI generatif untuk lokal bot Anda. Untuk melakukannya, ikuti langkah-langkah di[Optimalkan pembuatan dan kinerja bot Lex V2 dengan menggunakan AI generatif](generative-features.md). 

Menanggapi pertanyaan pelanggan dengan menggunakan Amazon Bedrock FM untuk mencari dan meringkas tanggapan FAQ. Maksud ini diaktifkan ketika ucapan tidak diklasifikasikan ke dalam maksud lain yang ada di bot. Perhatikan bahwa maksud ini tidak akan diaktifkan untuk ucapan yang terlewat saat memunculkan nilai slot. Setelah dikenali,`AMAZON.QnAIntent`, menggunakan model Amazon Bedrock yang ditentukan untuk mencari Basis Pengetahuan Amazon Bedrock yang dikonfigurasi dan menanggapi pertanyaan pelanggan.

**Awas**  
Anda tidak dapat menggunakan `AMAZON.QnAIntent` dan `AMAZON.KendraSearchIntent` di lokal bot yang sama.

Opsi toko pengetahuan berikut tersedia. Anda harus sudah membuat toko pengetahuan dan mengindeks dokumen di dalamnya.
+ OpenSearch Domain layanan - Berisi dokumen yang diindeks. Untuk membuat domain, ikuti langkah-langkah di [Membuat dan mengelola domain OpenSearch Layanan Amazon](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/createupdatedomains.html).
+ Indeks Amazon Kendra - Berisi dokumen FAQ yang diindeks. Untuk membuat indeks Amazon Kendra, ikuti langkah-langkah di [Membuat indeks](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html).
+ Basis Pengetahuan Amazon Bedrock - Berisi sumber data yang diindeks. Untuk menyiapkan Basis Pengetahuan Batuan Dasar Amazon, ikuti langkah-langkah di [Membangun Basis Pengetahuan](https://docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base.html).

Jika Anda memilih maksud ini, Anda mengonfigurasi bidang berikut dan kemudian pilih **Tambah** untuk menambahkan maksud.
+ **Model batuan dasar** — Pilih penyedia dan model pondasi yang akan digunakan untuk maksud ini. Pastikan untuk memeriksa model terbaru yang tersedia dan jadwal penghentian serta merencanakan migrasi yang sesuai. Untuk informasi selengkapnya, lihat [Siklus hidup model](https://docs.aws.amazon.com/bedrock/latest/userguide/model-lifecycle.html#versions-for-eol). 
+ **Toko pengetahuan** — Pilih sumber dari mana Anda ingin model menarik informasi dari untuk menjawab pertanyaan pelanggan. Sumber-sumber berikut tersedia.
  + **OpenSearch**— Konfigurasikan bidang berikut.
    + **Endpoint domain** — Menyediakan endpoint domain yang Anda buat untuk domain atau yang diberikan kepada Anda setelah pembuatan domain.
    + **Nama indeks** — Berikan indeks untuk mencari. Untuk informasi selengkapnya, lihat [Mengindeks data di OpenSearch Layanan Amazon](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/indexing.html).
    + Pilih bagaimana Anda ingin mengembalikan respons kepada pelanggan.
      + **Respons yang tepat** - Ketika opsi ini diaktifkan, nilai di bidang Jawaban digunakan sebagaimana adanya untuk respons bot. Model dasar Amazon Bedrock yang dikonfigurasi digunakan untuk memilih konten jawaban yang tepat apa adanya, tanpa sintesis atau ringkasan konten apa pun. Tentukan nama bidang tanya jawab yang dikonfigurasi dalam OpenSearch database.
      + **Sertakan bidang** - Mengembalikan jawaban yang dihasilkan oleh model menggunakan bidang yang Anda tentukan. Tentukan nama hingga lima bidang yang dikonfigurasi dalam OpenSearch database. Gunakan titik koma (;) untuk memisahkan bidang.
  + **Amazon Kendra** - Konfigurasikan bidang berikut.
    + Indeks **Amazon Kendra - Pilih indeks** Amazon Kendra yang Anda ingin bot Anda cari.
    + Filter **Amazon Kendra — Untuk membuat filter**, pilih kotak centang ini. Untuk informasi selengkapnya tentang format JSON filter penelusuran Amazon Kendra, lihat [Menggunakan atribut dokumen untuk memfilter](https://docs.aws.amazon.com/kendra/latest/dg/filtering.html#search-filtering) hasil penelusuran.
    + **Respons yang tepat** - Untuk membiarkan bot Anda mengembalikan respons persis yang dikembalikan oleh Amazon Kendra, pilih kotak centang ini. Jika tidak, model Amazon Bedrock yang Anda pilih menghasilkan respons berdasarkan hasil.
**catatan**  
Untuk menggunakan fitur ini, Anda harus terlebih dahulu menambahkan pertanyaan FAQ ke indeks Anda dengan mengikuti langkah-langkah di [Menambahkan pertanyaan yang sering diajukan (FAQs) ke indeks](https://docs.aws.amazon.com/kendra/latest/dg/in-creating-faq.html).
  + **Basis Pengetahuan Amazon Bedrock** - Jika Anda memilih opsi ini, tentukan ID Basis Pengetahuan Amazon Bedrock. Anda dapat menemukan ID dengan memeriksa halaman detail Pangkalan Pengetahuan Amazon Bedrock di konsol, atau dengan mengirimkan [GetKnowledgeBase](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetKnowledgeBase.html)permintaan.
    + **Respons yang tepat** - Ketika opsi ini diaktifkan, nilai di bidang Jawaban digunakan sebagaimana adanya untuk respons bot. Model dasar Amazon Bedrock yang dikonfigurasi digunakan untuk memilih konten jawaban yang tepat apa adanya, tanpa sintesis atau ringkasan konten apa pun. Untuk menggunakan respons yang tepat untuk Pangkalan Pengetahuan Amazon Bedrock, Anda perlu melakukan hal berikut:
      + Buat file JSON individual dengan setiap file yang berisi bidang jawaban yang berisi respons yang tepat yang perlu dikembalikan ke pengguna akhir.
      + **Saat mengindeks dokumen-dokumen ini di Basis Pengetahuan Batuan Dasar, pilih **Strategi Chunking sebagai No Chunking..****
      + Tentukan bidang jawaban di Amazon Lex V2, sebagai bidang Jawaban di Pangkalan Pengetahuan Batuan Dasar.

Tanggapan dari Qn AIntent akan disimpan ke dalam atribut permintaan seperti yang ditunjukkan di bawah ini:
+ `x-amz-lex:qnA-search-response`— Tanggapan dari Qn AIntent terhadap pertanyaan atau ucapan.
+ `x-amz-lex:qnA-search-response-source`— Menunjuk ke dokumen atau daftar dokumen yang digunakan untuk menghasilkan respons.
+ `x-amz-lex:qna-additional-context`— Konteks tambahan yang digunakan oleh Qn AIntent untuk menghasilkan respons.

**Konfigurasi model tambahan**

Saat Amazon.qn AIntent dipanggil, ia menggunakan templat prompt default yang menggabungkan instruksi dan konteks dengan kueri pengguna untuk membuat prompt yang dikirim ke model untuk pembuatan respons. Anda juga dapat memberikan prompt khusus atau memperbarui prompt default agar sesuai dengan kebutuhan Anda.

Anda dapat merekayasa template prompt dengan alat-alat berikut:

**Placeholder prompt** — Variabel yang telah ditentukan sebelumnya di Amazon.qn AIntent untuk Amazon Bedrock yang diisi secara dinamis saat runtime selama panggilan batuan dasar. Dalam prompt sistem, Anda dapat melihat placeholder ini dikelilingi oleh simbol. `$` Daftar berikut menjelaskan placeholder yang dapat Anda gunakan:


| Variabel | Digantikan oleh | Model | Diperlukan? | 
| --- | --- | --- | --- | 
| \$1query\$1hasil\$1 | Hasil yang diambil untuk kueri pengguna dari Knowledge Store | Model Batuan Dasar Terpilih | Ya | 
| \$1output\$1instruksi\$1 | Instruksi yang mendasari untuk memformat generasi respons dan kutipan. Berbeda dengan model. Jika Anda menentukan instruksi pemformatan Anda sendiri, kami sarankan Anda menghapus placeholder ini.  | Model Batuan Dasar Terpilih | Tidak | 
| \$1additional\$1context\$1 | Konteks tambahan yang digunakan oleh Qn AIntent untuk menghasilkan respons | Model Batuan Dasar Terpilih | Tidak | 
| \$1locale\$1 | Bahasa di mana bot akan menjawab pertanyaan pelanggan | Model Batuan Dasar Terpilih | Tidak | 

**Prompt default** yang digunakan adalah:

```
$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** diganti dengan:

```
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>
```

**catatan**  
Jika Anda memutuskan untuk tidak menggunakan instruksi default, maka output apa pun yang diberikan LLM akan dikembalikan apa adanya kembali ke pengguna akhir.  
Instruksi keluaran harus berisi<text></text> dan<passageId></passageId> tag dan instruksi untuk LLM untuk mengembalikan passageID untuk memberikan respons dan atribusi sumber.

**Dukungan konteks tambahan melalui atribut sesi**

Anda dapat meneruskan konteks tambahan ke `AMAZON.QnAIntent` saat runtime melalui atribut `x-amz-lex:qna-additional-context` session. Ini memungkinkan Anda untuk memberikan informasi tambahan yang dapat digunakan model di samping hasil penyimpanan pengetahuan saat menghasilkan respons. Konteks tambahan dimasukkan ke dalam template prompt melalui `$additional_context$` placeholder.

**Contoh:**

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

**Dukungan pemfilteran metadata Amazon Bedrock Knowledge Base melalui atribut sesi**

Anda dapat meneruskan filter metadata Amazon Bedrock Knowledge Base sebagai bagian dari atribut session. `x-amz-lex:bkb-retrieval-filter`

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

**catatan**  
Anda perlu menggunakan Amazon Bedrock Knowledge Base sebagai penyimpanan Data untuk Qn AIntent untuk menggunakan filter ini. Untuk informasi selengkapnya, lihat [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)

**Konfigurasi inferensi**

Anda dapat menentukan konfigurasi inferensi yang akan digunakan saat melakukan panggilan ke LLM menggunakan atribut session:
+ suhu: tipe Integer
+ TopP
+ MaxTokens

**Contoh:**

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

**Dukungan Bedrock Guardrails melalui atribut waktu pembuatan dan sesi**
+ Dengan menggunakan Konsol di Buildtime — Sediakan GuardrailsIdentifier dan. GuardrailsVersion Pelajari lebih lanjut di bagian Konfigurasi Model Tambahan.
+ Dengan menggunakan atribut Session — Anda juga dapat menentukan konfigurasi Guardrails menggunakan atribut sesi: `x-amz-lex:bedrock-guardrails-identifier` dan. `x-amz-lex:bedrock-guardrails-version`

[Untuk informasi lebih lanjut tentang penggunaan Bedrock Guardrails, lihat Guardrails.](https://docs.aws.amazon.com/bedrock/latest/userguide/guardrails.html)

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

Anda dapat memilih untuk memiliki beberapa Amazon.qn AIntents dalam satu lokal. Amazon Lex V2 mendukung hingga 5 Amazon.qn AIntents dalam lokal bot. 

Amazon.qn AIntent dapat dipicu jika salah satu kasus berikut benar:
+ Jika lokal bot hanya berisi 1 Amazon.qn AIntent dan maksud itu tidak mengandung contoh ucapan, maka itu diaktifkan ketika ucapan tidak diklasifikasikan ke dalam maksud lain yang ada di bot. Maksud ini diaktifkan ketika ucapan tidak diklasifikasikan ke dalam maksud lain yang ada di bot. Perhatikan bahwa maksud ini tidak akan diaktifkan untuk ucapan yang terlewat saat memunculkan nilai slot.
**catatan**  
Jika respons dari FM tidak memuaskan atau panggilan ke FM gagal, Amazon Lex V2 kemudian memanggil. `AMAZON.FallbackIntent`
+ Jika Amazon.qn AIntent memang berisi contoh ucapan, maka itu hanya diaktifkan ketika Amazon Lex V2 mengenali bahwa pengguna ingin memulai maksud tersebut berdasarkan input pengguna.
**catatan**  
Jika respons dari FM tidak memuaskan atau panggilan ke FM gagal, Amazon Lex V2 memanggil kegagalan langkah berikutnya, yang ditentukan dalam blok pemenuhan.

**catatan**  
Jika `botLocale` memiliki lebih dari 1 Amazon.qnAIntent, maka setiap Amazon.qn AIntent harus memiliki setidaknya 1 contoh ucapan.

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

**catatan**  
Untuk menggunakan kemampuan AI generatif menggunakan Amazon Q In Connect, Anda harus menyelesaikan prasyarat berikut:  
Arahkan ke konsol Amazon Connect dan buat instans Anda, jika Anda belum memilikinya, lihat [Memulai Amazon Connect](https://docs.aws.amazon.com/connect/latest/adminguide/amazon-connect-get-started.html).
Aktifkan Amazon Q di Connect untuk instans Anda, lihat [Mengaktifkan Amazon Q di Connect untuk instans Anda](https://docs.aws.amazon.com/connect/latest/adminguide/enable-q.html).

AMAZON. QinConnectIntent menanggapi pertanyaan pelanggan dengan menggunakan evolusi Amazon Connect Wisdom yang disempurnakan LLM yang memberikan rekomendasi waktu nyata untuk membantu pelanggan dan agen pusat kontak menyelesaikan masalah pelanggan dengan cepat dan akurat. Maksud ini diaktifkan ketika ucapan tidak diklasifikasikan ke dalam maksud lain yang ada di bot. Perhatikan bahwa maksud ini tidak akan diaktifkan untuk ucapan yang terlewat saat memunculkan nilai slot. Setelah dikenali, AMAZON. QinConnectIntent, menggunakan Q yang ditentukan di domain Connect untuk mencari Basis Pengetahuan Amazon Bedrock yang dikonfigurasi dan menanggapi pertanyaan pelanggan. 

**catatan**  
Anda tidak dapat menggunakan Amazon. QinConnectIntent bersama dengan Amazon.qn AIntent di lokal bot yang sama.
Jika Anda memilih bahasa lain selain Bahasa Inggris AS, Anda harus menyesuaikan permintaan layanan mandiri (`SELF_SERVICE_PRE_PROCESSING`dan`SELF_SERVICE_ANSWER_GENERATION`) untuk merespons dalam bahasa yang ditentukan. Untuk informasi selengkapnya tentang cara menyesuaikan prompt, lihat [Menyesuaikan Amazon Q di Connect](https://docs.aws.amazon.com/connect/latest/adminguide/customize-q.html#ai-prompts-customize-q).

Jika Anda memilih maksud ini, Anda perlu mengonfigurasi bidang berikut dan kemudian pilih **Simpan Maksud** untuk menambahkan maksud ke bot.
+ Konfigurasi Amazon Q In Connect - Berikan Nama Sumber Daya Amazon (ARN) dari asisten Amazon Q in Connect. Asisten Pola 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}$>`

Tanggapan dari QinConnectIntent akan disimpan ke dalam atribut permintaan seperti yang ditunjukkan di bawah ini:
+ `x-amz-lex:q-in-connect-response`— Tanggapan dari QinConnectIntent pertanyaan atau ucapan.

**Atribut Sesi Dikembalikan dari QinConnectIntent**

Interaksi dengan QinConnect intent menyediakan data tambahan tentang percakapan melalui atribut sesi. 

1. `x-amz-lex:q-in-connect:session-arn`— Pengenal unik untuk sesi yang dibuat dengan Amazon Q In Connect selama percakapan. 

1. `x-amz-lex:q-in-connect:conversation-status`— Status percakapan saat ini dengan QinConnect asisten atau domain. Ada tiga nilai yang mungkin untuk status ini:
   + `CLOSED`
   + `READY`
   + `PROCESSING`

1. `x-amz-lex:q-in-connect:conversation-status-reason`— Memberikan alasan untuk status saat ini yang dilaporkan dengan atribut di atas. Alasan yang mungkin adalah sebagai berikut:
   + `SUCCESS`— Menunjukkan bahwa pelanggan tidak memiliki apa-apa lagi untuk ditanyakan dan pertanyaan telah berhasil dijawab.
   + `FAILED`— Menunjukkan kegagalan saat menjawab pertanyaan pelanggan. Ini sebagian besar disebabkan oleh kegagalan untuk memahami pertanyaan pelanggan.
   + `REJECTED`— Menunjukkan bahwa asisten menolak untuk menjawab pertanyaan pelanggan, dan merekomendasikan agar pertanyaan ditangani di luar interaksi bot, seperti berbicara dengan orang atau agen, untuk mendapatkan informasi lebih lanjut.

**catatan**  
Saat bot dengan QinConnectIntent dipanggil selama interaksi pelanggan yang didorong oleh instans Amazon Connect, sesi Anda harus dibuat dan diteruskan dari instans Amazon Connect. Untuk membuat sesi, Amazon Connect Flows dapat dikonfigurasi dengan Amazon Q di langkah Connect.

**Batasan**
+ Anda tidak dapat menggunakan Amazon. QinConnectIntent bersama dengan maksud tanpa ucapan tertentu seperti Amazon.qn, AMAZONAIntent. BedrockAgentIntent di lokal bot yang sama.
+ Saat bot dengan QinConnectIntent dipanggil selama interaksi pelanggan yang didorong oleh instans Amazon Connect, sesi Anda harus dibuat dan diteruskan dari instans Amazon Connect. Untuk membuat sesi, Amazon Connect Flows dapat dikonfigurasi dengan langkah Amazon Q In Connect.
+ Tidak boleh ada lebih dari satu AMAZON. QinConnectIntent per bot lokal.
+ Domain Amazon Q in Connect digunakan dengan AMAZON. QinConnectIntent harus berada di Wilayah AWS yang sama dengan bot Amazon Lex V2.

**Izin**

Jika QinConnect Intent digunakan dalam bot Amazon Lex V2, dan bot menggunakan Service Linked Role (SLR), layanan Amazon Lex V2 memiliki izin untuk memperbarui kebijakan yang sesuai tentang peran untuk mengintegrasikannya dengan asisten Q in Connect. Jika bot menggunakan peran IAM khusus, maka pengguna perlu menambahkan izin ini secara manual ke peran IAM mereka.

Peran Tertaut Layanan akan diperbarui dengan izin berikut jika QinConnect maksud ditambahkan. Kebijakan baru akan ditambahkan untuk QinConnect akses:

```
{
    "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"]
                }
            }
        }
    ]
}
```

**catatan**  
`QInConnectKmsCMKPolicy`Pernyataan ini hanya diperlukan jika Anda menggunakan kunci KMS yang dikelola pelanggan dengan asisten Amazon Q in Connect.

**Kebijakan Kepercayaan**

```
{
    "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>

Menanggapi kata dan frasa yang memungkinkan pengguna untuk mengulangi pesan sebelumnya. Aplikasi Anda perlu menggunakan fungsi Lambda untuk menyimpan informasi intent sebelumnya dalam variabel sesi, atau Anda perlu menggunakan [GetSession](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_GetSession.html)operasi untuk mendapatkan informasi intent sebelumnya.

Ucapan umum:
+ ulangi
+ katakan itu lagi
+ ulangi itu

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

Menanggapi kata dan frasa yang memungkinkan pengguna untuk melanjutkan maksud yang dijeda sebelumnya. Fungsi atau aplikasi Lambda Anda harus mengelola informasi yang diperlukan untuk melanjutkan maksud sebelumnya.

Ucapan umum:
+ melanjutkan
+ terus
+ terus berjalan

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

Menanggapi kata dan frasa yang memungkinkan pengguna untuk berhenti memproses maksud saat ini dan memulai kembali dari awal. Anda dapat menggunakan fungsi Lambda Anda atau `PutSession` operasi untuk mendapatkan nilai slot pertama lagi.

Ucapan umum:
+ mulai dari awal
+ restart
+ mulai lagi

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

Menanggapi kata dan frasa yang menunjukkan bahwa pengguna ingin berhenti memproses maksud saat ini dan mengakhiri interaksi dengan bot. Fungsi atau aplikasi Lambda Anda harus menghapus atribut dan nilai jenis slot yang ada dan kemudian mengakhiri interaksi.

Ucapan umum:
+ berhenti
+ off
+ diam

# Menambahkan jenis slot
<a name="add-slot-types"></a>

Jenis slot menentukan nilai yang dapat diberikan pengguna untuk variabel intent Anda. Anda menentukan jenis slot untuk setiap bahasa sehingga nilainya spesifik untuk bahasa itu. Misalnya, untuk jenis slot yang mencantumkan warna cat, Anda dapat memasukkan nilai "" red dalam bahasa Inggris, "rouge" dalam bahasa Prancis, dan "rojo" dalam bahasa Spanyol.

Topik ini menjelaskan cara membuat jenis slot khusus yang memberikan nilai untuk slot maksud Anda. Anda juga dapat menggunakan tipe slot bawaan untuk nilai standar. Misalnya, Anda dapat menggunakan jenis slot bawaan `AMAZON.Country` untuk daftar negara di dunia. 

**Untuk membuat jenis slot**

1. Masuk ke AWS Management Console dan buka konsol Amazon Lex di [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).

1. Dari daftar bot, pilih bot yang ingin Anda tambahkan bahasa, lalu pilih **Struktur percakapan** dan kemudian **Semua bahasa**.

1. Pilih bahasa untuk menambahkan jenis slot, lalu pilih **jenis Slot**.

1. Pilih **Tambahkan jenis slot**, beri nama jenis slot Anda, lalu pilih **Tambah**.

1. Di editor jenis slot, tambahkan detail jenis slot Anda.
   + **Resolusi nilai slot** — Menentukan bagaimana nilai slot diselesaikan. Jika Anda memilih **Perluas nilai**, Amazon Lex V2 menggunakan nilai sebagai nilai representatif untuk pelatihan. Jika Anda menggunakan **Batasi nilai slot**, nilai yang diizinkan untuk slot dibatasi untuk yang Anda berikan.
   + **Nilai tipe slot** — Nilai untuk slot. Jika Anda memilih **Batasi nilai slot**, Anda dapat menambahkan sinonim untuk nilainya. Misalnya, untuk nilai “sepak bola” Anda dapat menambahkan sinonim “sepak bola.” Jika pengguna memasukkan “sepak bola” dalam percakapan dengan bot Anda, nilai sebenarnya dari slot tersebut adalah “sepak bola.”
   + **Gunakan nilai slot sebagai kosakata khusus** - Aktifkan opsi ini untuk membantu meningkatkan pengenalan nilai slot dan sinonim dalam percakapan audio. Jangan aktifkan opsi ini ketika nilai slot adalah istilah umum, seperti “ya,” “tidak,” “satu,” “dua,” “tiga,” dll.

1. Pilih **Simpan jenis slot**.

Amazon Lex V2 menawarkan jenis slot berikut:

**Topics**
+ [Jenis slot bawaan](built-in-slots.md)
+ [Jenis slot khusus](custom-slot-types.md)
+ [Jenis slot tata bahasa](building-srgs.md)
+ [Jenis slot komposit](composite-slots.md)

# Jenis slot bawaan
<a name="built-in-slots"></a>

Amazon Lex mendukung tipe slot bawaan yang menentukan bagaimana data dalam slot dikenali dan ditangani. Anda dapat membuat slot jenis ini dalam maksud Anda. Ini menghilangkan kebutuhan untuk membuat nilai enumerasi untuk data slot yang umum digunakan seperti tanggal, waktu, dan lokasi. Jenis slot bawaan tidak memiliki versi. 




| Jenis Slot | Deskripsi Singkat | Lokal yang Didukung | 
| --- | --- | --- | 
|  [AMAZON. AlphaNumeric](built-in-slot-alphanumeric.md)  | Mengenali kata-kata yang terdiri dari huruf dan angka. | 
|  [Amazon.kota](built-in-slot-city.md)  | Mengakui kata-kata yang mewakili kota. | Semua lokal | 
|  [Amazon.konfirmasi](built-in-slot-confirmation.md)  | Mengenali kata-kata yang berarti 'Ya', 'Tidak', 'Mungkin', dan 'Tidak tahu' dan mengubahnya menjadi format standar (Yes/No/Maybe/Dontidak tahu). | Semua lokal | 
|  [Amazon.negara](built-in-slot-country.md)  | Mengakui kata-kata yang mewakili suatu negara. | Semua lokal | 
|  [Amazon.currency](built-in-slot-currency.md)  | Mengenali kata-kata yang mewakili nilai mata uang dan mengubahnya menjadi singkatan dan nilai mata uang standar. | Semua lokal | 
|  [Amazon.tanggal](built-in-slot-date.md)  | Mengenali kata-kata yang mewakili tanggal dan mengubahnya menjadi format standar. | Semua lokal | 
|  [Amazon.durasi](built-in-slot-duration.md)  | Mengenali kata-kata yang mewakili durasi dan mengubahnya menjadi format standar. | Semua lokal | 
|  [AMAZON. EmailAddress](built-in-slot-email.md)  | Mengenali kata-kata yang mewakili alamat email dan mengubahnya menjadi alamat email standar. | Semua lokal | 
|  [AMAZON. FirstName](built-in-slot-first-name.md)  | Mengenali kata-kata yang mewakili nama depan. | Semua lokal | 
|  [AMAZON. LastName](built-in-slot-last-name.md)  | Mengenali kata-kata yang mewakili nama belakang. | Semua lokal | 
|  [Amazon.number](built-in-slot-number.md)  | Mengenali kata-kata numerik dan mengubahnya menjadi digit. | Semua lokal | 
|  [Amazon.persentase](built-in-slot-percent.md)  | Mengenali kata-kata yang mewakili persentase dan mengubahnya menjadi angka dan tanda persen (%). | Semua lokal | 
|  [AMAZON. PhoneNumber](built-in-slot-phone.md)  | Mengenali kata-kata yang mewakili nomor telepon dan mengubahnya menjadi string numerik. | Semua lokal | 
|  [Amazon.state](built-in-slot-state.md)  | Mengakui kata-kata yang mewakili suatu negara. | Semua lokal | 
|  [AMAZON. StreetName](built-in-slot-street-name.md)  | Mengenali kata-kata yang mewakili nama jalan. | Semua lokal | 
|  [Amazon.waktu](built-in-slot-time.md)  | Mengenali kata-kata yang menunjukkan waktu dan mengubahnya menjadi format waktu. | Semua lokal | 
|  [AMAZON. UKPostalKode](built-in-slot-uk-postal-code.md)  | Mengenali kata-kata yang mewakili kode pos Inggris dan mengubahnya menjadi bentuk standar. | Hanya bahasa Inggris (Inggris) (en-GB) | 
|  [AMAZON. FreeFormInput](built-in-slot-free-form.md)  | Mengenali string yang terdiri dari kata atau karakter apa pun. | Semua lokal | 

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

Mengenali string yang terdiri dari huruf dan angka, seperti. **APQ123**

Anda dapat menggunakan jenis `AMAZON.AlphaNumeric` slot untuk string yang berisi: 
+ Karakter abjad, seperti **ABC**
+ Karakter numerik, seperti **123**
+ Kombinasi karakter alfanumerik, seperti **ABC123**

Jenis `AMAZON.AlphaNumeric` slot mendukung input menggunakan gaya ejaan. Anda dapat menggunakan spell-by-letter dan spell-by-word gaya untuk membantu pelanggan Anda memasukkan huruf. Untuk informasi selengkapnya, lihat [Menangkap nilai slot dengan gaya ejaan selama percakapan](spelling-styles.md).

Anda dapat menambahkan ekspresi reguler ke jenis `AMAZON.AlphaNumeric` slot untuk memvalidasi nilai yang dimasukkan untuk slot. Misalnya, Anda dapat menggunakan ekspresi reguler untuk memvalidasi:
+ Kode pos Kanada
+ Nomor SIM
+ Nomor identifikasi kendaraan

Gunakan ekspresi reguler standar. Amazon Lex V2 mendukung karakter berikut dalam ekspresi reguler:
+ A-Z, a-z
+ 0-9

Amazon Lex V2 juga mendukung karakter Unicode dalam ekspresi reguler. Bentuknya adalah`\uUnicode`. Gunakan empat digit untuk mewakili karakter Unicode. Misalnya, `[\u0041-\u005A]` setara dengan [A-Z].

Operator ekspresi reguler berikut tidak didukung:
+ Repeater tak terbatas: \$1, \$1, atau \$1x,\$1 tanpa batas atas.
+ Kartu liar (.)

Panjang maksimum ekspresi reguler adalah 300 karakter. Panjang maksimum string yang disimpan dalam jenis `AMAZON.AlphaNumeric` slot yang menggunakan ekspresi reguler adalah 30 karakter.

Berikut ini adalah beberapa contoh ekspresi reguler.
+ String alfanumerik, seperti **APQ123** atau**APQ1**: `[A-Z]{3}[0-9]{1,3}` atau yang lebih dibatasi `[A-DP-T]{3} [1-5]{1,3}`
+ Format Internasional Surat Prioritas Layanan Pos AS, seperti**CP123456789US**: `CP[0-9]{9}US`
+ Nomor routing bank, seperti**123456789**: `[0-9]{9}`

Untuk mengatur ekspresi reguler untuk jenis slot, gunakan konsol atau [CreateSlotType](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateSlotType.html)operasi. Ekspresi reguler divalidasi saat Anda menyimpan jenis slot. Jika ekspresi tidak valid, Amazon Lex V2 mengembalikan pesan kesalahan.

Saat Anda menggunakan ekspresi reguler dalam jenis slot, Amazon Lex V2 memeriksa input ke slot jenis itu terhadap ekspresi reguler. Jika input cocok dengan ekspresi, nilai diterima untuk slot. Jika input tidak cocok, Amazon Lex V2 meminta pengguna untuk mengulangi input. 

# Amazon.kota
<a name="built-in-slot-city"></a>

Menyediakan daftar kota lokal dan dunia. Jenis slot mengenali variasi umum nama kota. Amazon Lex V2 tidak mengonversi dari variasi ke nama resmi.

Contoh:
+ New York
+ Reykjavik
+ Tokyo
+ Versailles

# Amazon.konfirmasi
<a name="built-in-slot-confirmation"></a>

Jenis slot ini mengenali frasa input yang sesuai dengan frasa dan kata 'Ya', 'Tidak', 'Mungkin', dan 'Tidak tahu' untuk Amazon Lex V2 dan mengubahnya menjadi salah satu dari empat nilai. Ini dapat digunakan untuk menangkap konfirmasi atau pengakuan dari pengguna. Berdasarkan nilai akhir yang diselesaikan, Anda dapat membuat kondisi untuk mendesain beberapa jalur percakapan.

Misalnya:

 jika \$1confirmation\$1 = “Ya”, penuhi maksudnya

 lain, dapatkan slot lain 

Contoh:
+ Ya: Ya, Ya, Ok, Tentu, saya memilikinya, saya setuju...
+ Tidak: Tidak, Negatif, Tidak, Lupakan, Saya akan menolak, Tidak mungkin...
+ Mungkin: Mungkin, Mungkin, Kadang-kadang, saya mungkin, Itu bisa benar...
+ Tidak tahu: Entah, Tidak diketahui, Tidak tahu, Tidak yakin tentang itu, Siapa tahu...

Per 17 Agustus 2023, jika ada jenis slot khusus yang ada bernama “Konfirmasi”, nama harus diubah untuk menghindari konflik dengan Konfirmasi slot bawaan. Di navigasi sisi kiri di konsol Lex, buka jenis slot (untuk jenis slot khusus yang ada bernama Konfirmasi) dan perbarui nama jenis slot. Nama jenis slot baru tidak boleh “Konfirmasi,” yang merupakan kata kunci yang dicadangkan untuk jenis slot konfirmasi bawaan.

# Amazon.negara
<a name="built-in-slot-country"></a>

Nama-nama negara di seluruh dunia. Contoh:
+ Australia
+ Germany
+ Jepang
+ Amerika Serikat
+ Uruguay

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

Mengkonversi kata-kata yang mewakili mata uang menjadi standar ISO 4217 kode mata uang alfabet dan angka. Amazon Lex V2 mengenali mata uang tetapi tidak mengonversi dari satu mata uang ke mata uang lainnya.

Untuk informasi selengkapnya, lihat [Kode mata uang - ISO 4217 di situs](https://www.iso.org/iso-4217-currency-codes.html) web Organisasi Internasional untuk Standardisasi (ISO).

Mata uang yang diwakili disusun sebagai berikut: `{Unit} {Amount}`
+ \$1Unit\$1 mengacu pada unit mata uang tertentu (misalnya, USD).
+ \$1Jumlah\$1 menunjukkan nilai moneter, diformat menjadi dua tempat desimal (misalnya, 300,00).

Contoh (semua contoh di bawah ini menggunakan lokal en-US; lokal yang berbeda dapat menghasilkan hasil yang berbeda):
+ “3USD”: USD 3,00
+ “USD300": USD 300,00
+ “3 sen”: USD 0,30
+ “\$11,56": USD 1,56
+ “5c”: USD 0,05
+ “1 dolar”: USD 1,00
+ “lima lima belas”: USD 515,00
+ “lima dolar lima belas sen”: USD 5,15
+ “5 usd dan 1/2": USD 5,50

# Amazon.tanggal
<a name="built-in-slot-date"></a>

Mengkonversi kata-kata yang mewakili tanggal menjadi format tanggal.

Tanggal diberikan sesuai maksud Anda dalam format tanggal ISO-8601. Tanggal yang diterima niat Anda di slot dapat bervariasi tergantung pada frasa spesifik yang diucapkan oleh pengguna.
+ Ucapan yang dipetakan ke tanggal tertentu, seperti “hari ini,” “sekarang,” atau “dua puluh lima November,” dikonversi ke tanggal lengkap:. `2020-11-25` Ini default ke tanggal *pada atau setelah tanggal saat* ini.
+ Ucapan yang dipetakan ke future week, seperti “minggu depan,” dikonversi ke tanggal hari terakhir minggu ini. Dalam format ISO-8601, minggu dimulai pada hari Senin dan berakhir pada hari Minggu. Misalnya, jika hari ini 2020-11-25, “minggu depan” dikonversi menjadi. `2020-11-29` Tanggal yang dipetakan ke minggu saat ini atau sebelumnya dikonversi ke hari pertama dalam seminggu. Misalnya, jika hari ini 2020-11-25, “minggu lalu” dikonversi menjadi. `2020-11-16`
+ Ucapan yang dipetakan ke bulan masa depan, tetapi bukan hari tertentu, seperti “bulan depan,” dikonversi ke hari terakhir bulan itu. Misalnya, jika hari ini 2020-11-25, “bulan depan” dikonversi menjadi. `2020-12-31` Untuk tanggal yang dipetakan ke bulan saat ini atau sebelumnya, konversi ke hari pertama bulan itu. Misalnya, jika hari ini 2020-11-25, “bulan ini” dipetakan ke. `2020-11-01`
+ Ucapan yang dipetakan ke tahun masa depan, tetapi bukan bulan atau hari tertentu, seperti “tahun depan,” dikonversi ke hari terakhir tahun berikutnya. Misalnya, jika hari ini 2020-11-25, “tahun depan” dikonversi menjadi. `2021-12-31` Untuk tanggal yang dipetakan ke tahun saat ini atau tahun sebelumnya, konversi ke hari pertama tahun ini. Misalnya, jika hari ini 2020-11-25, “tahun lalu” dikonversi menjadi. `2019-01-01`

# Amazon.durasi
<a name="built-in-slot-duration"></a>

Mengkonversi kata-kata yang menunjukkan durasi menjadi durasi numerik.

Durasi diselesaikan ke format berdasarkan format durasi [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601#Durations),. `PnYnMnWnDTnHnMnS` Ini `P` menunjukkan bahwa ini adalah durasi, `n` adalah nilai numerik, dan huruf kapital yang mengikuti `n` adalah elemen tanggal atau waktu tertentu. Misalnya, `P3D` berarti 3 hari. A `T` digunakan untuk menunjukkan bahwa nilai yang tersisa mewakili elemen waktu daripada elemen tanggal.

Contoh:
+ “sepuluh menit”: `PT10M`
+ “lima jam”: `PT5H`
+ “tiga hari”: `P3D`
+ “empat puluh lima detik”: `PT45S`
+ “delapan minggu”: `P8W`
+ “tujuh tahun”: `P7Y`
+ “lima jam sepuluh menit”: `PT5H10M`
+ “dua tahun tiga jam sepuluh menit”: `P2YT3H10M`

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

Mengenali kata-kata yang mewakili alamat email yang diberikan sebagai nama pengguna @domain. Alamat dapat menyertakan karakter khusus berikut dalam nama pengguna: garis bawah (\$1), tanda hubung (-), titik (.), dan tanda plus (\$1).

Jenis `AMAZON.EmailAddress` slot mendukung input menggunakan gaya ejaan. Anda dapat menggunakan spell-by-letter dan spell-by-word gaya untuk membantu pelanggan Anda memasukkan alamat email. Untuk informasi selengkapnya, lihat [Menangkap nilai slot dengan gaya ejaan selama percakapan](spelling-styles.md).

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

Nama depan yang umum digunakan. Jenis slot ini mengenali nama formal, nama panggilan informal, dan nama yang terdiri dari lebih dari satu kata. Nama yang dikirim ke intent Anda adalah nilai yang dikirim oleh pengguna. Amazon Lex V2 tidak mengonversi dari nama panggilan ke nama resmi.

Untuk nama depan yang terdengar sama tetapi dieja berbeda, Amazon Lex V2 mengirimkan maksud Anda satu bentuk umum.

Jenis `AMAZON.FirstName` slot mendukung input menggunakan gaya ejaan. Anda dapat menggunakan spell-by-letter dan spell-by-word gaya untuk membantu pelanggan Anda memasukkan nama. Untuk informasi selengkapnya, lihat [Menangkap nilai slot dengan gaya ejaan selama percakapan](spelling-styles.md).

Contoh:
+ Emily
+ John
+ Sophie
+ Anil Kumar

AMAZON. FirstName juga mengembalikan daftar nama yang terkait erat berdasarkan nilai aslinya. Anda dapat menggunakan daftar nilai yang diselesaikan untuk memulihkan dari kesalahan ketik, mengonfirmasi nama dengan pengguna, atau melakukan pencarian database untuk nama yang valid di direktori pengguna Anda.

Misalnya, input “John” dapat mengakibatkan pengembalian nama terkait tambahan seperti “John J” dan “John-Paul”. 

Berikut ini menunjukkan format respons untuk tipe slot `AMAZON.FirstName` bawaan:

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

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

Nama belakang yang umum digunakan. Untuk nama yang terdengar sama yang dieja berbeda, Amazon Lex V2 mengirimkan maksud Anda satu bentuk umum.

Jenis `AMAZON.LastName` slot mendukung input menggunakan gaya ejaan. Anda dapat menggunakan spell-by-letter dan spell-by-word gaya untuk membantu pelanggan Anda memasukkan nama. Untuk informasi selengkapnya, lihat [Menangkap nilai slot dengan gaya ejaan selama percakapan](spelling-styles.md).

Contoh:
+ Brosky
+ Dasher
+ Evers
+ Parres
+ Welt

AMAZON. LastName juga mengembalikan daftar nama yang terkait erat berdasarkan nilai aslinya. Anda dapat menggunakan daftar nilai yang diselesaikan untuk memulihkan dari kesalahan ketik, mengonfirmasi nama dengan pengguna, atau melakukan pencarian database untuk nama yang valid di direktori pengguna Anda.

Misalnya, input “Smith” dapat mengakibatkan pengembalian nama terkait tambahan seperti “Smyth” dan “Smithe”.

Berikut ini menunjukkan format respons untuk tipe slot `AMAZON.LastName` bawaan:

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

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

Mengkonversi kata atau angka yang mengekspresikan angka menjadi digit, termasuk angka desimal. Tabel berikut menunjukkan bagaimana jenis `AMAZON.Number` slot menangkap kata-kata numerik.


| Input | Respons | 
| --- | --- | 
| seratus dua puluh tiga poin empat lima | 123.45 | 
| seratus dua puluh tiga titik empat lima | 123.45 | 
| titik empat dua | 0,42 | 
| poin empat puluh dua | 0,42 | 
| 232.998 | 232.998 | 
| 50 | 50 | 
| -15 | -15 | 
| minus 15 | -15 | 
| minus lima belas poin dua empat lima | -15,245 | 

# Amazon.persentase
<a name="built-in-slot-percent"></a>

Mengkonversi kata dan simbol yang mewakili persentase menjadi nilai numerik dengan tanda persen (%).

Jika pengguna memasukkan angka tanpa tanda persen atau kata “persen,” nilai slot diatur ke nomor tersebut. Tabel berikut menunjukkan bagaimana jenis `AMAZON.Percentage` slot menangkap persentase.


| Input | Respons | 
| --- | --- | 
| 50 persen | 50% | 
| 0,4 persen | 0,4% | 
| 23,5% | 23,5% | 
| dua puluh lima persen | 25% | 

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

Mengkonversi angka atau kata-kata yang mewakili nomor telepon ke dalam format string tanpa tanda baca sebagai berikut.


| Tipe | Deskripsi | Input | Hasil | 
| --- | --- | --- | --- | 
| Nomor internasional dengan tanda plus (\$1) terkemuka | Nomor 11 digit dengan tanda plus terkemuka. |  \$161 7 4445 1061 \$11 (509) 555-1212  |   `+61744431061`   `+15095551212`   | 
| Nomor internasional tanpa tanda plus (\$1) terkemuka | Nomor 11 digit tanpa tanda plus utama |  1 (509) 555-1212 61 7 4445 1061  |   `15095551212`   `61744451061`   | 
| Nomor nasional | 10 digit nomor tanpa kode internasional |  (03) 5115 4444 (509) 555-1212  |   `0351154444`   `5095551212`   | 
| Nomor lokal | nomor telepon tanpa kode internasional atau kode area | 555-1212 |  5551212  | 

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

Nama-nama wilayah geografis dan politik di dalam negara. 

Contoh:
+ Bayern
+ Prefektur Fukushima
+ Pasifik Barat Laut
+ Queensland
+ Wales

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

Nama-nama jalan dalam alamat jalan yang khas. Ini hanya termasuk nama jalan, bukan nomor rumah.

Contoh:
+ Jalan Canberra
+ Jalan Depan
+ Jalan Pasar

# Amazon.waktu
<a name="built-in-slot-time"></a>

Mengubah kata-kata yang mewakili waktu menjadi nilai waktu. `AMAZON.Time`dapat menyelesaikan waktu yang tepat, nilai ambigu, dan rentang waktu. Nilai slot dapat diselesaikan ke rentang waktu berikut:
+ SAYA
+ PM
+ MO (pagi)
+ AF (sore)
+ EV (malam)
+ NI (malam)

Saat pengguna memasukkan waktu yang ambigu, Amazon Lex V2 menggunakan `slots` atribut peristiwa Lambda untuk meneruskan resolusi untuk waktu yang ambigu ke fungsi Lambda Anda. Misalnya, jika bot Anda meminta pengguna untuk waktu pengiriman, pengguna dapat merespons dengan mengatakan “jam 10.” Kali ini ambigu. Itu berarti 10:00 AM atau 10:00 PM. Dalam hal ini, nilai di `interpretedValue` lapangan adalah`null`, dan `resolvedValues` bidang berisi dua kemungkinan resolusi saat itu. Amazon Lex V2 memasukkan yang berikut ini ke dalam fungsi Lambda:

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

Saat pengguna merespons dengan waktu yang tidak ambigu, Amazon Lex V2 mengirimkan waktu ke fungsi Lambda Anda di `interpretedValue` bidang atribut `slots` peristiwa Lambda. Misalnya, jika pengguna Anda merespons prompt untuk waktu pengiriman dengan "10:00 AM,” Amazon Lex V2 memasukkan yang berikut ke dalam fungsi Lambda:

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

Saat pengguna merespons prompt untuk waktu pengiriman dengan “di pagi hari,” Amazon Lex V2 memasukkan hal berikut ke dalam fungsi Lambda:

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

Untuk informasi selengkapnya tentang data yang dikirim dari Amazon Lex V2 ke fungsi Lambda, lihat. [AWS Lambdaformat acara masukan untuk Lex V2](lambda-input-format.md)

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

Mengonversi kata-kata yang mewakili kode pos Inggris ke format standar untuk kode pos di Britania Raya. Jenis `AMAZON.UKPostalCode` slot memvalidasi dan menyelesaikan kode pos ke satu set format standar, tetapi tidak memeriksa untuk memastikan bahwa kode pos valid. Aplikasi Anda harus memvalidasi kode pos.

Jenis `AMAZON.UKPostalCode` slot hanya tersedia di bahasa Inggris (UK) (en-GB) lokal.

Jenis `AMAZON.UKPostalCode` slot mendukung input menggunakan gaya ejaan. Anda dapat menggunakan spell-by-letter dan spell-by-word gaya untuk membantu pelanggan Anda memasukkan huruf. Untuk informasi selengkapnya, lihat [Menangkap nilai slot dengan gaya ejaan selama percakapan](spelling-styles.md).

Jenis slot hanya mengenali format kode pos yang valid yang tercantum di bawah ini, yang digunakan di Britania Raya. Format yang valid adalah (“A” menampilkan kembali huruf, dan “9" mewakili digit):
+ AA9SEBUAH 9AA
+ A9A 9AA
+ A9 9AA
+ A99 9AA
+ AA9 9AA
+ AA99 9AA

Untuk input teks, pengguna dapat memasukkan campuran huruf besar dan kecil. Pengguna dapat menggunakan atau menghilangkan ruang dalam kode pos. Nilai yang diselesaikan akan selalu menyertakan ruang di lokasi yang tepat untuk kode pos.

Untuk masukan lisan, pengguna dapat berbicara karakter individu, atau mereka dapat menggunakan pengucapan huruf ganda, seperti “ganda A” atau “ganda 9". Mereka juga dapat menggunakan pengucapan dua digit, seperti “sembilan puluh sembilan” untuk “99". 

**catatan**  
Tidak semua kode pos Inggris diakui. Hanya format yang tercantum di atas yang didukung.

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

`AMAZON.FreeFormInput`dapat digunakan untuk menangkap input formulir gratis dari pengguna akhir. Ini mengenali string yang terdiri dari kata-kata atau karakter. Nilai yang diselesaikan adalah seluruh ucapan input.

Contoh:

Bot: Harap berikan umpan balik dari pengalaman panggilan Anda. 

Pengguna: Saya mendapat jawaban atas semua pertanyaan saya, dan saya dapat menyelesaikan transaksi.

Catatan:
+ `AMAZON.FreeFormInput`dapat digunakan untuk menangkap input formulir gratis apa adanya dari pengguna akhir.
+ `AMAZON.FreeFormInput`tidak dapat digunakan dalam ucapan sampel maksud.
+ `AMAZON.FreeFormInput`tidak dapat memiliki contoh ucapan slot.
+ `AMAZON.FreeFormInput`hanya dikenali ketika diminta untuk.
+ `AMAZON.FreeFormInput`tidak mendukung menunggu dan melanjutkan.
+ `AMAZON.FreeFormInput`saat ini tidak didukung di saluran Obrolan Amazon Connect.
+ Ketika `AMAZON.FreeFormInput` slot ditimbulkan, tidak `FallbackIntent` akan dipicu.
+ Ketika `AMAZON.FreeFormInput` slot ditimbulkan, tidak akan ada sakelar maksud.

# Jenis slot khusus
<a name="custom-slot-types"></a>

Untuk setiap intent, Anda dapat menentukan parameter yang menunjukkan informasi yang dibutuhkan intent untuk memenuhi permintaan pengguna. Parameter ini, atau slot, memiliki tipe. *Jenis slot* adalah daftar nilai yang digunakan Amazon Lex V2 untuk melatih model pembelajaran mesin untuk mengenali nilai slot. Misalnya, Anda dapat menentukan jenis slot yang disebut `Genres` dengan nilai-nilai seperti “komedi,” “petualangan,” “dokumenter,” dan sebagainya. Anda dapat menentukan sinonim untuk nilai jenis slot. Misalnya, Anda dapat mendefinisikan sinonim “lucu” dan “lucu” untuk nilai “komedi.” 

![\[Buat jenis slot khusus.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/slots/custom-slot-type.png)


Anda dapat mengonfigurasi jenis slot untuk memperluas nilai slot. Nilai slot akan digunakan sebagai data pelatihan dan model akan menyelesaikan slot dengan nilai yang diberikan oleh pengguna jika mirip dengan nilai slot dan sinonim dari nilai-nilai tersebut. Ini adalah perilaku default. Amazon Lex V2 menyimpan daftar kemungkinan resolusi untuk slot. Setiap entri dalam daftar memberikan *nilai yang diselesaikan* yang diakui Amazon Lex V2 sebagai kemungkinan tambahan untuk slot. Nilai yang diselesaikan adalah upaya terbaik untuk mencocokkan nilai slot. Daftar ini berisi hingga lima nilai.

Atau, Anda dapat mengonfigurasi jenis slot untuk membatasi resolusi ke nilai slot. Dalam hal ini, model akan menyelesaikan nilai slot yang dimasukkan oleh pengguna ke nilai slot yang ada hanya jika sama dengan nilai slot itu atau itu adalah sinonim. Misalnya, jika pengguna memasukkan “lucu” itu akan menyelesaikan nilai slot “komedi.”

Ketika nilai yang dimasukkan oleh pengguna adalah sinonim dari nilai jenis slot, model mengembalikan nilai jenis slot sebagai entri pertama dalam daftar. `resolvedValues` Misalnya, jika pengguna memasukkan “lucu,” model mengisi `originalValue` bidang dengan nilai “lucu” dan entri pertama di bidang ResolvedValues dengan “komedi.” Anda dapat mengkonfigurasi `valueSelectionStrategy` ketika Anda membuat atau memperbarui jenis slot dengan [CreateSlotType](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateSlotType.html)operasi sehingga nilai slot diisi dengan nilai pertama dalam daftar resolusi. 

 Jenis slot khusus mendukung input menggunakan gaya ejaan. Anda dapat menggunakan spell-by-letter dan spell-by-word gaya untuk membantu pelanggan Anda memasukkan huruf. Untuk informasi selengkapnya, lihat [Menangkap nilai slot dengan gaya ejaan selama percakapan](spelling-styles.md). 

 Jika Anda menggunakan fungsi Lambda, peristiwa input ke fungsi tersebut menyertakan daftar resolusi yang disebut. `resolvedValues` Contoh berikut menunjukkan bagian slot input ke fungsi Lambda:

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

Untuk setiap jenis slot, Anda dapat menentukan maksimum 10.000 nilai dan sinonim. Setiap bot dapat memiliki jumlah total 50.000 nilai jenis slot dan sinonim. Misalnya, Anda dapat memiliki 5 jenis slot, masing-masing dengan 5.000 nilai dan 5.000 sinonim, atau Anda dapat memiliki 10 jenis slot, masing-masing dengan 2.500 nilai dan 2.500 sinonim.

Jenis slot khusus tidak boleh memiliki nama yang sama dengan jenis slot bawaan. Misalnya, jenis slot khusus tidak boleh diberi nama dengan kata kunci yang dicadangkan dari Tanggal, Nomor, atau Konfirmasi. Kata kunci ini disediakan untuk jenis slot bawaan. Untuk daftar semua jenis slot bawaan, lihat[Jenis slot bawaan](built-in-slots.md).

# Jenis slot tata bahasa
<a name="building-srgs"></a>

Dengan jenis slot tata bahasa, Anda dapat menulis tata bahasa Anda sendiri dalam format XHTML sesuai spesifikasi SRGS untuk mengumpulkan informasi dalam percakapan. Amazon Lex V2 mengenali ucapan yang cocok dengan aturan yang ditentukan dalam tata bahasa. Anda juga dapat memberikan aturan interpretasi semantik menggunakan ECMAScript tag dalam file tata bahasa. Amazon Lex kemudian mengembalikan properti yang disetel dalam tag sebagai nilai yang diselesaikan saat kecocokan terjadi.

Anda hanya dapat membuat jenis slot tata bahasa di bahasa Inggris (Australia), Inggris (Inggris), dan bahasa Inggris (AS) lokal.

Ada dua bagian untuk jenis slot tata bahasa. Yang pertama adalah tata bahasa itu sendiri ditulis menggunakan format spesifikasi SRGS. Tata bahasa menafsirkan ucapan dari pengguna. Jika ucapan diterima oleh tata bahasa itu cocok, jika tidak maka akan ditolak. Jika ucapan dicocokkan, itu diteruskan ke skrip jika ada.

Yang kedua adalah bagian dari jenis slot tata bahasa adalah skrip opsional yang ditulis ECMAScript yang mengubah input ke nilai yang diselesaikan yang dikembalikan oleh jenis slot. Misalnya, Anda dapat menggunakan skrip untuk mengonversi angka yang diucapkan menjadi digit. ECMAScript pernyataan terlampir dalam <tag>elemen. 

Contoh berikut adalah dalam format XHTML per spesifikasi SRGS yang menunjukkan tata bahasa yang valid diterima oleh Amazon Lex V2. Ini mendefinisikan jenis slot tata bahasa yang menerima nomor kartu dan menentukan apakah mereka untuk akun reguler atau premium. Untuk informasi selengkapnya tentang sintaks yang dapat diterima, lihat [Definisi tata bahasa](grammar-srgs-spec.md) dan [Format skrip](grammar-ecmascript-spec.md) topiknya.

```
<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>
```

Tata bahasa di atas hanya menerima dua jenis nomor kartu: 7241 atau 7001. Keduanya mungkin secara opsional diawali dengan “nomor kartu”. Ini juga berisi ECMAScript tag yang dapat digunakan untuk interpretasi semantik. Dengan interpretasi semantik, ucapan “kartu nomor tujuh dua empat satu” akan mengembalikan objek berikut:

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

Objek ini dikembalikan sebagai string JSON-serialized dalam `resolvedValues` objek dikembalikan oleh [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)dan operasi. [StartConversation](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_StartConversation.html)

## Menambahkan tipe slot tata bahasa
<a name="adding-grammar-slot-type"></a>

**Untuk menambahkan jenis slot tata bahasa**

1. Unggah definisi XHTML dari jenis slot Anda ke bucket S3. Catat nama bucket dan path ke file.
**catatan**  
Ukuran file maksimum adalah 100 KB.

1. Masuk ke AWS Management Console dan buka konsol Amazon Lex di [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).

1. Dari menu kiri, pilih **Bots** dan kemudian pilih bot untuk menambahkan jenis slot tata bahasa.

1. Pilih **Lihat bahasa**, lalu pilih bahasa untuk menambahkan jenis slot tata bahasa.

1. Pilih **Lihat jenis slot**.

1. Pilih **Tambahkan jenis slot**, lalu pilih **Tambahkan jenis slot tata bahasa**.

1. Beri nama jenis slot, lalu pilih **Tambah**.

1. Pilih bucket S3 yang berisi file definisi Anda dan masukkan path ke file. Pilih **Simpan jenis slot**.

# Definisi tata bahasa
<a name="grammar-srgs-spec"></a>

Topik ini menunjukkan bagian-bagian dari spesifikasi SRGS yang didukung Amazon Lex V2. Semua aturan didefinisikan dalam spesifikasi SRGS. Untuk informasi selengkapnya, lihat [Spesifikasi tata bahasa pengenalan ucapan versi 1.0](https://www.w3.org/TR/speech-grammar/) W3C rekomendasi.

**Topics**
+ [Deklarasi header](srgs-header.md)
+ [Elemen XHTML yang didukung](srgs-supported-xml.md)
+ [Token](srgs-tokens.md)
+ [Referensi aturan](srgs-rule-reference.md)
+ [Urutan dan enkapsulasi](srgs-sequence.md)
+ [Mengulangi](srgs-repeats.md)
+ [Bahasa](srgs-language.md)
+ [Tag](srgs-tags.md)
+ [Bobot](grammar-weights.md)

[Dokumen ini mencakup materi yang disalin dan berasal dari Spesifikasi Tata Bahasa Pengenalan Ucapan W3C Versi 1.0 (tersedia di https://www.w3. org/TR/speech-tata bahasa/](https://www.w3.org/TR/speech-grammar/)). Informasi kutipan berikut:

[Hak Cipta](http://www.w3.org/Consortium/Legal/ipr-notice#Copyright) © 2004 [W3C®](http://www.w3.org/) ([MIT](http://www.csail.mit.edu/), [ERCIM, [Keio](http://www.keio.ac.jp/), Semua](http://www.ercim.org/) Hak Dilindungi. [Kewajiban](http://www.w3.org/Consortium/Legal/ipr-notice#Legal_Disclaimer) W3C, [merek dagang](http://www.w3.org/Consortium/Legal/ipr-notice#W3C_Trademarks), [penggunaan dokumen, dan aturan](http://www.w3.org/Consortium/Legal/copyright-documents) [lisensi perangkat lunak berlaku](http://www.w3.org/Consortium/Legal/copyright-software).

Dokumen spesifikasi SRGS, [Rekomendasi W3C](https://www.w3.org/2004/02/Process-20040205/tr.html#RecsW3C), tersedia dari W3C di bawah lisensi berikut.

## Teks lisensi
<a name="license-text"></a>

Lisensi

Dengan menggunakan and/or penyalinan dokumen ini, atau dokumen W3C dari mana pernyataan ini ditautkan, Anda (penerima lisensi) setuju bahwa Anda telah membaca, memahami, dan akan mematuhi syarat dan ketentuan berikut:

Izin untuk menyalin, dan mendistribusikan isi dokumen ini, atau dokumen W3C dari mana pernyataan ini ditautkan, dalam media apa pun untuk tujuan apa pun dan tanpa biaya atau royalti dengan ini diberikan, asalkan Anda menyertakan yang berikut pada SEMUA salinan dokumen, atau bagiannya, yang Anda gunakan:
+ Tautan atau URL ke dokumen W3C asli.
+ [http://www.keio.ac.jp/](http://www.keio.ac.jp/) [http://www.w3. org/Consortium/Legal/2015/doc-lisensi](http://www.w3.org/Consortium/Legal/2015/doc-license)”
+ *Jika ada*, STATUS dokumen W3C.

Jika ruang memungkinkan, penyertaan teks lengkap **PEMBERITAHUAN** ini harus disediakan. Kami meminta agar atribusi kepengarangan diberikan dalam perangkat lunak, dokumen, atau item atau produk lain yang Anda buat sesuai dengan implementasi isi dokumen ini, atau bagiannya.

Tidak ada hak untuk membuat modifikasi atau turunan dari dokumen W3C yang diberikan sesuai dengan lisensi ini, kecuali sebagai berikut: Untuk memfasilitasi implementasi spesifikasi teknis yang ditetapkan dalam dokumen ini, siapa pun dapat menyiapkan dan mendistribusikan karya turunan dan bagian dari dokumen ini dalam perangkat lunak, dalam materi pendukung yang menyertai perangkat lunak, dan dalam dokumentasi perangkat lunak, ASALKAN semua karya tersebut mencakup pemberitahuan di bawah ini. Namun, publikasi karya turunan dari dokumen ini untuk digunakan sebagai spesifikasi teknis secara tegas dilarang.

[Selain itu, “Komponen Kode” —Web IDL di bagian yang ditandai dengan jelas sebagai Web IDL; dan markup yang ditentukan W3C (HTML, CSS, dan sebagainya) dan kode bahasa pemrograman komputer ditandai dengan jelas sebagai contoh kode— dilisensikan di bawah Lisensi Perangkat Lunak W3C.](http://www.w3.org/Consortium/Legal/copyright-software)

Pemberitahuan adalah:

“Hak Cipta © 2015 W3C® (MIT, ERCIM, Keio, Beihang). Perangkat lunak atau dokumen ini mencakup materi yang disalin dari atau berasal dari [judul dan URI dokumen W3C].”

Penafian

DOKUMEN INI DISEDIAKAN “SEBAGAIMANA ADANYA,” DAN PEMEGANG HAK CIPTA TIDAK MEMBUAT PERNYATAAN ATAU JAMINAN, TERSURAT MAUPUN TERSIRAT, TERMASUK, TETAPI TIDAK TERBATAS PADA, JAMINAN KELAYAKAN UNTUK DIPERJUALBELIKAN, KESESUAIAN UNTUK TUJUAN TERTENTU, NON-PELANGGARAN, ATAU JUDUL; BAHWA ISI DOKUMEN COCOK UNTUK TUJUAN APA PUN; ATAU BAHWA IMPLEMENTASI KONTEN TERSEBUT TIDAK AKAN MELANGGAR PATEN PIHAK KETIGA, HAK CIPTA, MEREK DAGANG ATAU HAK-HAK LAINNYA.

PEMEGANG HAK CIPTA TIDAK AKAN BERTANGGUNG JAWAB ATAS KERUSAKAN LANGSUNG, TIDAK LANGSUNG, KHUSUS ATAU KONSEKUENSIAL YANG TIMBUL DARI PENGGUNAAN DOKUMEN ATAU KINERJA ATAU IMPLEMENTASI ISINYA.

Nama dan merek dagang pemegang hak cipta TIDAK boleh digunakan dalam iklan atau publisitas yang berkaitan dengan dokumen ini atau isinya tanpa izin tertulis sebelumnya yang spesifik. Judul hak cipta dalam dokumen ini akan selalu ada pada pemegang hak cipta.

# Deklarasi header
<a name="srgs-header"></a>

Tabel berikut menunjukkan deklarasi header didukung oleh jenis slot tata bahasa. Untuk informasi selengkapnya, lihat [Deklarasi header tata bahasa](https://www.w3.org/TR/speech-grammar/#S4.1) dalam rekomendasi W3C *spesifikasi tata bahasa pengenalan ucapan versi 1*.


| Pernyataan | Persyaratan spesifikasi | Formulir XHTML | Dukungan Amazon Lex | Spesifikasi | 
| --- | --- | --- | --- | --- | 
| Versi tata bahasa | Diperlukan | [4.3](https://www.w3.org/TR/speech-grammar/#S4.3): version atribut pada elemen grammar | Diperlukan | SRGS | 
| Ruang nama XML | Diperlukan (hanya XHTML) | [4.3](https://www.w3.org/TR/speech-grammar/#S4.3): xmlns atribut pada elemen grammar | Diperlukan | SRGS | 
| Jenis dokumen | Diperlukan (hanya XHTML) | [4.3](https://www.w3.org/TR/speech-grammar/#S4.3): XMLDOCTYPE | Disarankan | SRGS | 
| Pengkodean karakter | Disarankan | [4.4](https://www.w3.org/TR/speech-grammar/#S4.4): encoding atribut dalam deklarasi XML | Disarankan | SRGS | 
| Bahasa | Diperlukan dalam mode suara Diabaikan dalam mode DTMF | [4.5](https://www.w3.org/TR/speech-grammar/#S4.5): xml:lang atribut pada grammar elemen | Diperlukan dalam mode suara Diabaikan dalam mode DTMF | SRGS | 
| Modus | Opsional | [4.6](https://www.w3.org/TR/speech-grammar/#S4.6): mode atribut pada elemen grammar | Opsional | SRGS | 
| Aturan akar | Opsional | [4.7](https://www.w3.org/TR/speech-grammar/#S4.7): root atribut pada elemen grammar | Diperlukan | SRGS | 
| Format tag | Opsional | [4.8](https://www.w3.org/TR/speech-grammar/#S4.8): tag-format atribut pada elemen grammar | String literal ECMAScript dan didukung | SRGS, SISR | 
| URI Dasar | Opsional | [4.9](https://www.w3.org/TR/speech-grammar/#S4.9): xml:base atribut pada elemen grammar | Opsional | SRGS | 
| Leksikon pengucapan | Opsional, beberapa diizinkan | [4.10](https://www.w3.org/TR/speech-grammar/#S4.`0): elemen lexicon | Tidak didukung | SRGS, PLS | 
| Metadata | Opsional, beberapa diizinkan | [4.11.1: elemen](https://www.w3.org/TR/speech-grammar/#S4.11.1) meta | Diperlukan | SRGS | 
| Metadata XML | Opsional, hanya XHTML | [4.11.2: elemen](https://www.w3.org/TR/speech-grammar/#S4.11.2) metadata | Opsional | SRGS | 
| Tag | Opsional, beberapa diizinkan | [4.12](https://www.w3.org/TR/speech-grammar/#S4.12): elemen tag | Tag global tidak didukung | SRGS | 

**Contoh**

```
<?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">
```

# Elemen XHTML yang didukung
<a name="srgs-supported-xml"></a>

Amazon Lex V2 mendukung elemen XHTML berikut untuk tata bahasa kustom:
+ `<item>`
+ `<token>`
+ `<tag>`
+ `<one-of>`
+ `<rule-ref>`

# Token
<a name="srgs-tokens"></a>

Tabel berikut menunjukkan spesifikasi token yang didukung oleh jenis slot tata bahasa. Untuk informasi selengkapnya, lihat [Token](https://www.w3.org/TR/speech-grammar/#S2.1) dalam *spesifikasi tata bahasa pengenalan ucapan versi 1 rekomendasi* W3C.


| Jenis token | Contoh | Didukung? | 
| --- | --- | --- | 
| Token tunggal yang tidak dikutip | halo | Ya | 
| Token tunggal yang tidak dikutip: non-abjad | 2 | Ya | 
| Token yang dikutip tunggal, tidak ada spasi putih | "halo" | Ya, jatuhkan tanda kutip ganda jika hanya berisi satu token | 
| Dua token dibatasi oleh ruang putih | bon voyage | Ya | 
| Empat token dibatasi oleh ruang putih | ini adalah ujian | Ya | 
| Token yang dikutip tunggal, termasuk spasi putih | “San Francisco | Tidak | 
| <token>Token XHTML tunggal dalam tag | <token>San Fransisco</token> | Tidak (sama dengan token kutip tunggal dengan spasi putih) | 

**Catatan**
+ *Token kutip tunggal termasuk ruang putih* — Spesifikasi mengharuskan kata-kata yang dilampirkan dalam tanda kutip ganda diperlakukan sebagai token tunggal. Amazon Lex V2 memperlakukannya sebagai token yang dibatasi spasi putih.
+ *Token XHTML tunggal dalam* <token>— Spesifikasi membutuhkan kata-kata yang dibatasi oleh <token>untuk mewakili satu token. Amazon Lex V2 memperlakukannya sebagai token yang dibatasi spasi putih.
+ Amazon Lex V2 memunculkan kesalahan validasi ketika salah satu penggunaan ditemukan dalam tata bahasa Anda.

**Contoh**

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

# Referensi aturan
<a name="srgs-rule-reference"></a>

Tabel berikut merangkum berbagai bentuk referensi aturan yang dimungkinkan dalam dokumen tata bahasa. Untuk informasi lebih lanjut, lihat [Referensi aturan](https://www.w3.org/TR/speech-grammar/#S2.2) dalam *spesifikasi tata bahasa pengenalan ucapan versi 1 rekomendasi* W3C. 


| Jenis referensi | Formulir XHTML | Didukung | 
| --- | --- | --- | 
| [2.2.1 Referensi](https://www.w3.org/TR/speech-grammar/#S2.2.1) aturan lokal eksplisit | <ruleref uri="\$1rulename"/> | Ya | 
| [2.2.2](https://www.w3.org/TR/speech-grammar/#S2.2.2) [Referensi eksplisit ke aturan bernama dari tata bahasa yang diidentifikasi oleh URI](https://www.w3.org/TR/speech-grammar/#term-uri) | <ruleref uri="grammarURI\$1rulename"/> | Tidak | 
| [2.2.2](https://www.w3.org/TR/speech-grammar/#S2.2.2) [Referensi implisit ke aturan akar tata bahasa yang diidentifikasi oleh URI](https://www.w3.org/TR/speech-grammar/#term-uri) | <ruleref uri="grammarURI"/> | Tidak | 
| [2.2.2](https://www.w3.org/TR/speech-grammar/#S2.2.2) [Referensi eksplisit ke aturan bernama tata bahasa yang diidentifikasi oleh [URI dengan tipe](https://www.w3.org/TR/speech-grammar/#term-uri) media](https://www.w3.org/TR/speech-grammar/#term-media-type) | <ruleref uri="grammarURI\$1rulename" type="media-type"/> | Tidak | 
| [2.2.2](https://www.w3.org/TR/speech-grammar/#S2.2.2) [Referensi implisit ke aturan akar tata bahasa yang diidentifikasi oleh [URI dengan tipe](https://www.w3.org/TR/speech-grammar/#term-uri) media](https://www.w3.org/TR/speech-grammar/#term-media-type) | <ruleref uri="grammarURI" type="media-type"/> | Tidak | 
| [2.2.3 Definisi](https://www.w3.org/TR/speech-grammar/#S2.2.3) aturan khusus | `<ruleref special="NULL"/>` `<ruleref special="VOID"/>` `<ruleref special="GARBAGE"/>` | Tidak | 

**Catatan**

1. Grammar URI adalah URI eksternal. Misalnya, `http://grammar.example.com/world-cities.grxml`.

1. Jenis media dapat berupa:
   + `application/srgs+xml`
   + `text/plain`

**Contoh**

```
<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>
```

# Urutan dan enkapsulasi
<a name="srgs-sequence"></a>

Contoh berikut menunjukkan urutan yang didukung. Untuk informasi lebih lanjut, lihat [Urutan dan enkapsulasi](https://www.w3.org/TR/speech-grammar/#S2.3) dalam *spesifikasi tata bahasa pengenalan ucapan versi 1 rekomendasi* W3C. 

**Contoh**

```
<!-- 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>
```

# Mengulangi
<a name="srgs-repeats"></a>

Tabel berikut menunjukkan ekspansi berulang yang didukung untuk aturan. Untuk informasi selengkapnya, lihat [Pengulangan](https://www.w3.org/TR/speech-grammar/#S2.5) dalam *spesifikasi tata bahasa pengenalan ucapan versi 1* rekomendasi W3C. 


| Formulir XHTMLContoh | Perilaku | Didukung? | 
| --- | --- | --- | 
| *ulangi = “n”* ulangi = “6" | Ekspresi yang terkandung diulang tepat “n” kali. “n” harus “0" atau bilangan bulat positif. | Ya | 
| *ulangi = “m-n”* ulangi = “4-6" | Ekspansi yang terkandung diulang antara waktu “m” dan “n” (inklusif). “m” dan “n” keduanya harus “0" atau bilangan bulat positif, dan “m” harus kurang dari atau sama dengan “n”. | Ya | 
| *ulangi = “m-”* ulangi = “3-” | Ekspansi yang terkandung diulang “m” kali atau lebih (inklusif). “m” harus “0" atau bilangan bulat postif. Misalnya, “3-” menyatakan bahwa ekspansi yang terkandung dapat terjadi tiga, empat, lima, atau lebih kali. | Ya | 
| *ulangi = “0-1"*  | Ekspansi yang terkandung adalah opsional. | Ya | 
| <item repeat="2-4" repeat-prob="0.8"> |   | Tidak | 

# Bahasa
<a name="srgs-language"></a>

Diskusi berikut berlaku untuk pengidentifikasi bahasa yang diterapkan pada tata bahasa. Untuk informasi selengkapnya, lihat [Bahasa](https://www.w3.org/TR/speech-grammar/#S2.7) dalam *spesifikasi tata bahasa pengenalan ucapan versi 1 rekomendasi* W3C. 

Secara default tata bahasa adalah dokumen bahasa tunggal dengan [pengidentifikasi bahasa](https://www.w3.org/TR/speech-grammar/#term-language) yang disediakan dalam deklarasi bahasa di header [tata](https://www.w3.org/TR/speech-grammar/#S4.1) bahasa. Semua token dalam tata bahasa itu, kecuali dinyatakan lain, **akan ditangani sesuai dengan bahasa tata bahasa**. **Deklarasi bahasa tingkat tata bahasa tidak didukung.**

Dalam contoh berikut:

1. Deklarasi header tata bahasa untuk bahasa “en-US” **didukung** oleh Amazon Lex V2.

1. Lampiran bahasa tingkat item (disorot dalam*red*) **tidak didukung**. Amazon Lex V2 memunculkan kesalahan validasi jika lampiran bahasa berbeda dari deklarasi header.

```
<?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>
```

# Tag
<a name="srgs-tags"></a>

Diskusi berikut berlaku untuk tag yang didefinisikan untuk tata bahasa. Untuk informasi selengkapnya, lihat [Tag](https://www.w3.org/TR/speech-grammar/#S2.6) dalam *spesifikasi tata bahasa pengenalan ucapan versi 1 rekomendasi* W3C. 

Berdasarkan spesifikasi SRGS, tag dapat didefinisikan dengan cara berikut:

1. Sebagai bagian dari deklarasi header seperti yang dijelaskan dalam[Deklarasi header](srgs-header.md).

1. Sebagai bagian dari** <rule>definisi.

Format tag berikut didukung:
+ `semantics/1.0`(SISR, ECMAScript)
+ `semantics/1.0-literals`(Literal string SISR)

Format tag berikut tidak didukung:
+ `swi-semantics/1.0`(Nuansa kepemilikan)

**Contoh**

```
<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>
```

# Bobot
<a name="grammar-weights"></a>

Anda dapat menambahkan atribut *weight* ke elemen. Berat adalah nilai floating point positif yang mewakili sejauh mana frasa dalam item ditingkatkan selama pengenalan suara. Untuk informasi lebih lanjut, lihat [Bobot](https://www.w3.org/TR/speech-grammar/) dalam spesifikasi tata bahasa pengenalan ucapan versi 1 rekomendasi W3C.

Bobot harus lebih besar dari 0 dan kurang dari atau sama dengan 10, dan hanya dapat memiliki satu tempat desimal. Jika beratnya lebih besar dari 0 dan kurang dari 1, frasa tersebut ditingkatkan secara negatif. Jika beratnya lebih besar dari 1 dan kurang dari atau sama dengan 10, frasa tersebut ditingkatkan secara positif. Berat 1 sama dengan tidak memberi bobot sama sekali, dan tidak ada dorongan untuk frasa tersebut.

Menetapkan bobot yang sesuai untuk item untuk meningkatkan kinerja pengenalan suara adalah tugas yang sulit. Berikut adalah beberapa tips yang dapat Anda ikuti untuk menetapkan bobot:
+ Mulailah dengan tata bahasa tanpa bobot item yang ditetapkan.
+ Tentukan pola mana dalam pidato yang sering salah diidentifikasi.
+ Terapkan nilai yang berbeda untuk bobot sampai Anda melihat peningkatan dalam kinerja pengenalan suara, dan tidak ada regresi.

**Contoh 1**

Misalnya, jika Anda memiliki tata bahasa untuk bandara, dan Anda melihat bahwa *New York* sering salah diidentifikasi sebagai *Newark*, Anda dapat secara positif meningkatkan New York dengan menetapkan bobot 5.

```
<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>
```

**Contoh 2**

Misalnya, Anda memiliki tata bahasa untuk kode reservasi maskapai yang dimulai dengan alfabet bahasa Inggris diikuti oleh tiga digit. Kode reservasi kemungkinan besar dimulai dengan B atau D, tetapi Anda mengamati bahwa B sering salah diidentifikasi sebagai P, dan D sebagai T. Anda dapat secara positif meningkatkan B dan 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>
```

# Format skrip
<a name="grammar-ecmascript-spec"></a>

Amazon Lex V2 mendukung ECMAScript fitur-fitur berikut untuk mendefinisikan tata bahasa.

Amazon Lex V2 mendukung ECMAScript fitur berikut saat menentukan tag dalam tata bahasa. `tag-format`harus dikirim ke `semantics/1.0` ketika ECMAScript tag digunakan dalam tata bahasa. Untuk informasi lebih lanjut, lihat spesifikasi bahasa [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**
+ [Pernyataan variabel](ecma-variable.md)
+ [Ekspresi](ecma-expression.md)
+ [Jika pernyataan](ecma-if.md)
+ [Pernyataan switch](ecma-switch.md)
+ [Deklarasi fungsi](ecma-function.md)
+ [Pernyataan iterasi](ecma-iteration.md)
+ [Pernyataan blok](ecma-block.md)
+ [Komentar](ecma-comments.md)
+ [Pernyataan yang tidak didukung](ecma-unsupported.md)

Dokumen ini berisi materi dari ECMAScript standar (tersedia di [https://www.ecma-international. org/publications-and-standards/standards/ecma-262/](https://www.ecma-international.org/publications-and-standards/standards/ecma-262/)). Dokumen spesifikasi ECMAScript bahasa tersedia dari Ecma International di bawah lisensi berikut.

## Teks lisensi
<a name="ecma-license"></a>

© 2020 Ecma Internasional

Dokumen ini dapat disalin, diterbitkan, dan didistribusikan kepada orang lain, dan karya turunan tertentu darinya dapat disiapkan, disalin, diterbitkan, dan didistribusikan, secara keseluruhan atau sebagian, asalkan pemberitahuan hak cipta di atas dan Lisensi Hak Cipta dan Penafian ini disertakan pada semua salinan dan karya turunan tersebut. Satu-satunya karya turunan yang diizinkan berdasarkan Lisensi Hak Cipta dan Penafian ini adalah: 

(i) karya yang menggabungkan seluruh atau sebagian dokumen ini untuk tujuan memberikan komentar atau penjelasan (seperti versi dokumen yang dianotasi), 

(ii) karya yang menggabungkan semua atau sebagian dari dokumen ini untuk tujuan memasukkan fitur-fitur yang menyediakan aksesibilitas, 

(iii) terjemahan dokumen ini ke dalam bahasa selain bahasa Inggris dan ke dalam format yang berbeda dan 

(iv) bekerja dengan memanfaatkan spesifikasi ini dalam produk kesesuaian standar dengan menerapkan (misalnya, dengan menyalin dan menempel seluruhnya atau sebagian) fungsionalitas di dalamnya. 

Namun, isi dokumen ini sendiri tidak dapat diubah dengan cara apa pun, termasuk dengan menghapus pemberitahuan hak cipta atau referensi ke Ecma International, kecuali jika diperlukan untuk menerjemahkannya ke dalam bahasa selain bahasa Inggris atau ke dalam format yang berbeda. 

Versi resmi dokumen Ecma International adalah versi bahasa Inggris di situs web Ecma International. Dalam hal terjadi perbedaan antara versi terjemahan dan versi resmi, versi resmi akan mengatur. 

Izin terbatas yang diberikan di atas bersifat abadi dan tidak akan dicabut oleh Ecma International atau penerus atau penugasannya. Dokumen ini dan informasi yang terkandung di sini disediakan atas dasar “SEBAGAIMANA ADANYA” dan ECMA INTERNATIONAL MENYANGKAL SEMUA JAMINAN, TERSURAT MAUPUN TERSIRAT, TERMASUK TETAPI TIDAK TERBATAS PADA JAMINAN APA PUN BAHWA PENGGUNAAN INFORMASI DI SINI TIDAK AKAN MELANGGAR HAK KEPEMILIKAN ATAU JAMINAN TERSIRAT ATAS KELAYAKAN UNTUK MERCHANTABILITY ATAU KESESUAIAN UNTUK TUJUAN TERTENTU.”

# Pernyataan variabel
<a name="ecma-variable"></a>

Pernyataan variabel mendefinisikan satu atau lebih variabel.

```
var x = 10;
var x = 10, var y = <expression>;
```

# Ekspresi
<a name="ecma-expression"></a>

Anda dapat menambahkan string ekspresi untuk menjalankan fungsi di Amazon Lex V2. Tabel ini menunjukkan sintaks dan contoh yang dapat digunakan dalam ekspresi SRGS.


| Jenis ekspresi | Sintaksis | Contoh | Didukung? | 
| --- | --- | --- | --- | 
| Ekspresi reguler literal | String literal yang berisi karakter khusus [regex](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions) yang valid | <pre>"^\d\.$"</pre> | Tidak | 
| Fungsi | function functionName(parameters) \$1 functionBody\$1 | <pre>var x = function calc() {<br />    return 10;<br />}</pre> | Tidak | 
| Delete | delete expression | <pre>delete obj.property;</pre> | Tidak | 
| Kekosongan | void expression | <pre>void (2 == '2');</pre> | Tidak | 
| Tipeof | typeof expression | <pre>typeof 42;</pre> | Tidak | 
| Indeks anggota | expression [ expressions ] | <pre>var fruits = ["apple"];<br />fruits[0];</pre> | Ya | 
| Dot anggota | expression . identifier | <pre>out.value</pre> | Ya | 
| Pendapat | expression (arguments) | <pre>new Date('1994-10-11')</pre> | Ya | 
| Posting kenaikan | expression\$1\$1 | <pre>var x=10; x++;</pre> | Ya | 
| Posting penurunan | expression-- | <pre>var x=10; x--;</pre> | Ya | 
| Pra kenaikan | \$1\$1expression | <pre>var x=10; ++x;</pre> | Ya | 
| Pra penurunan | --expression | <pre>var x=10; --x;</pre> | Ya | 
| Unary plus/Unary minus | \$1expression / -expression | <pre>+x / -x;</pre> | Ya | 
| Sedikit tidak | \$1 expression | <pre>const a = 5;<br />console.log( ~a );</pre> | Ya | 
| Logis tidak | \$1 expression | <pre>!(a > 0 || b > 0)</pre> | Ya | 
| Multiplikatif | expression ('\$1' \$1 '/' \$1 '%') expression | <pre>(x + y) * (a / b)</pre> | Ya | 
| Aditif | expression ('\$1' \$1 '-') expression | <pre>(a + b) - (a - (a + b))</pre> | Ya | 
| Pergeseran bit | expression ('<<' \$1 '>>' \$1 '>>>') expression | <pre>(a >> b) >>> c</pre> | Ya | 
| Relatif | expression ('<' \$1 '>' \$1 '<=' \$1 '>=') expression | <pre>if (a > b) { ... }</pre> | Ya | 
| Masuk | expression in expression | <pre>fruits[0] in otherFruits;</pre> | Ya | 
| Kesetaraan | expression ('==' \$1 '\$1=' \$1 '===' \$1 '\$1===') expression | <pre>if (a == b) { ... }</pre> | Ya | 
| Bit dan/ xor/atau | expression ('&' \$1 '^' \$1 '\$1') expression | <pre>a & b / a ^ b / a | b</pre> | Ya | 
| Logis dan/atau | expression ('&&' \$1 '\$1\$1') expression | <pre>if (a && (b ||c)) { ...}</pre> | Ya | 
| Ternary  | expression ? expression : expression | <pre>a > b ? obj.prop : 0</pre> | Ya | 
| Penugasan | expression = expression | <pre>out.value = "string";</pre> | Ya | 
| Operator penugasan | expression ('\$1=' \$1 '/=' \$1 '\$1=' \$1 '-=' \$1 '%=') expression  | <pre>a *= 10;</pre> | Ya | 
| Penugasan operator bitwise | expression ('<<=' \$1 '>>=' \$1 '>>>=' \$1 '&=' \$1 '^=' \$1 '\$1=') expression | <pre>a <<= 10;</pre> | Ya | 
| Pengidentifikasi | identifierSequence[di mana *IdentifierSequence* adalah urutan karakter yang valid](https://developer.mozilla.org/en-US/docs/Glossary/Identifier) | <pre>fruits=[10, 20, 30];</pre> | Ya | 
| Null literal | null | <pre>x = null;</pre> | Ya | 
| Boolean harfiah | true \$1 false | <pre>x = true;</pre> | Ya | 
| String literal | 'string' / "string" | <pre>a = 'hello',<br />b = "world";</pre> | Ya | 
| Desimal literal | integer [.] digits [exponent] | <pre>111.11 e+12</pre> | Ya | 
| Hex literal | 0 (x \$1 X)[0-9a-fA-F] | <pre>0x123ABC</pre> | Ya | 
| Literal oktal | O [0-7] | <pre>"O51"</pre> | Ya | 
| Array literal | [ expression, ... ] | <pre>v = [a, b, c];</pre> | Ya | 
| Objek literal | \$1property: value, ...\$1 | <pre>out = {value: 1, flag: false};</pre> | Ya | 
| Kurung | ( expressions ) | <pre>x + (x + y)</pre> | Ya | 

# Jika pernyataan
<a name="ecma-if"></a>

Anda dapat menambahkan pernyataan if untuk menjalankan fungsi di Amazon Lex V2. Contoh ini menunjukkan sintaks yang dapat digunakan dalam ekspresi SRGS.

```
if (expressions) {
    statements;
} else {
    statements;
}
```

**Catatan:** Dalam contoh sebelumnya, `expressions` dan `statements` harus menjadi salah satu yang didukung dari dokumen ini.

# Pernyataan switch
<a name="ecma-switch"></a>

Anda dapat menambahkan pernyataan switch untuk menjalankan fungsi di Amazon Lex V2. Contoh ini menunjukkan sintaks yang dapat digunakan dalam ekspresi SRGS.

```
switch (expression) {
    case (expression):
     statements
     .
     .
     .
   default:
      statements
}
```

**Catatan:** Dalam contoh sebelumnya, `expressions` dan `statements` harus menjadi salah satu yang didukung dari dokumen ini.

# Deklarasi fungsi
<a name="ecma-function"></a>

Anda dapat menambahkan deklarasi fungsi untuk melakukan fungsi di Amazon Lex V2. Contoh ini menunjukkan sintaks yang dapat digunakan dalam ekspresi SRGS.

```
function functionIdentifier([parameterList, ...]) {
     <function body>
}
```

# Pernyataan iterasi
<a name="ecma-iteration"></a>

Pernyataan iterasi dapat berupa salah satu dari berikut ini:

```
// 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
}
```

# Pernyataan blok
<a name="ecma-block"></a>

Anda dapat menambahkan blok pernyataan untuk melakukan fungsi di Amazon Lex V2. Contoh ini menunjukkan sintaks yang dapat digunakan dalam ekspresi SRGS.

```
{
   statements
}

// Example
{
    x = 10;
   if (x > 10) {
     console.log("greater than 10");
   }
}
```

**Catatan:** Dalam contoh sebelumnya, yang `statements` disediakan di blok harus salah satu yang didukung dari dokumen ini.

# Komentar
<a name="ecma-comments"></a>

Anda dapat menambahkan komentar di Amazon Lex V2. Contoh ini menunjukkan sintaks yang dapat digunakan dalam ekspresi SRGS.

```
// Single Line Comments
"// <comment>"

// Multineline comments
/**
<comment>
**/
```

# Pernyataan yang tidak didukung
<a name="ecma-unsupported"></a>

Amazon Lex V2 tidak mendukung ECMAScript fitur-fitur berikut.

**Topics**
+ [Pernyataan kosong](#ecma-unsupported-empty)
+ [Lanjutkan pernyataan](#ecma-unsupported-continue)
+ [Pernyataan istirahat](#ecma-unsupported-break)
+ [Pernyataan pengembalian](#ecma-unsupported-return)
+ [Lempar pernyataan](#ecma-unsupported-throw)
+ [Coba pernyataan](#ecma-unsupported-try)
+ [Pernyataan debugger](#ecma-unsupported-debugger)
+ [Pernyataan berlabel](#ecma-unsupported-labelled)
+ [Deklarasi kelas](#ecma-unsupported-class)

## Pernyataan kosong
<a name="ecma-unsupported-empty"></a>

Pernyataan kosong digunakan untuk tidak memberikan pernyataan. Berikut ini adalah sintaks untuk pernyataan kosong:

```
;
```

## Lanjutkan pernyataan
<a name="ecma-unsupported-continue"></a>

Pernyataan lanjutkan tanpa label didukung dengan[Pernyataan iterasi](ecma-iteration.md). Pernyataan lanjutkan dengan label tidak didukung.

```
// continue with label
// this allows the program to jump to a
// labelled statement (see labelled statement below)
continue <label>;
```

## Pernyataan istirahat
<a name="ecma-unsupported-break"></a>

Pernyataan break tanpa label didukung dengan[Pernyataan iterasi](ecma-iteration.md). Pernyataan break dengan label tidak didukung.

```
// break with label
// this allows the program to break out of a
// labelled statement (see labelled statement below)
break <label>;
```

## Pernyataan pengembalian
<a name="ecma-unsupported-return"></a>

```
return expression;
```

## Lempar pernyataan
<a name="ecma-unsupported-throw"></a>

Pernyataan throw digunakan untuk melempar pengecualian yang ditentukan pengguna.

```
throw expression;
```

## Coba pernyataan
<a name="ecma-unsupported-try"></a>

```
try {
  statements
}
catch (expression) {
  statements
}
finally {
  statements
}
```

## Pernyataan debugger
<a name="ecma-unsupported-debugger"></a>

Pernyataan debugger digunakan untuk memanggil fungsionalitas debugging yang disediakan oleh lingkungan.

```
debugger;
```

## Pernyataan berlabel
<a name="ecma-unsupported-labelled"></a>

Pernyataan berlabel dapat digunakan dengan `break` atau `continue` pernyataan.

```
label:
   statements


// Example
let str = '';

loop1:
for (let i = 0; i < 5; i++) {
  if (i === 1) {
    continue loop1;
  }
  str = str + i;
}

console.log(str);
```

## Deklarasi kelas
<a name="ecma-unsupported-class"></a>

```
class Rectangle {
  constructor(height, width) {
    this.height = height;
    this.width = width;
  }
}
```

# Tata bahasa industri
<a name="grammar-industry"></a>

*Tata bahasa industri* adalah satu set file XMLuntuk digunakan dengan jenis slot [tata bahasa](https://docs.aws.amazon.com/lexv2/latest/dg/building-srgs.html). Anda dapat menggunakannya untuk memberikan pengalaman pengguna akhir yang konsisten dengan cepat saat Anda memigrasikan alur kerja respons suara interaktif ke Amazon Lex V2. Anda dapat memilih dari berbagai tata bahasa pra-bangun di tiga domain: layanan keuangan, asuransi, dan telekomunikasi. Ada juga seperangkat tata bahasa generik yang dapat Anda gunakan sebagai titik awal untuk tata bahasa Anda sendiri. 

 Tata bahasa berisi aturan untuk mengumpulkan informasi dan [ECMAScripttag](https://docs.aws.amazon.com/lexv2/latest/dg/grammar-ecmascript-spec.html) untuk interpretasi semantik.

## Tata bahasa untuk layanan keuangan ([unduh](samples/financial-grammars.zip))
<a name="financial-services-grammars"></a>

Tata bahasa berikut didukung untuk layanan keuangan: nomor akun dan perutean, nomor kartu kredit dan pinjaman, skor kredit, tanggal pembukaan dan penutupan akun, dan nomor Jaminan Sosial.

### Nomor rekening
<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>
```

### Nomor perutean
<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>
```

### Nomor kartu kredit
<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 Pinjaman
<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>
```

### Skor kredit
<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>
```

### Tanggal pembukaan rekening
<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>
```

### Tanggal pembayaran otomatis
<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>
```

### Tanggal kedaluwarsa kartu kredit
<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>
```

### Tanggal pernyataan
<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>
```

### Tanggal transaksi
<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>
```

### Jumlah transfer
<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>
```

### Nomor Jaminan Sosial
<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>
```

## Tata bahasa untuk asuransi ([unduh](samples/insurance-grammars.zip))
<a name="insurance-grammers"></a>

Tata bahasa berikut didukung untuk domain asuransi: nomor klaim dan polis, nomor SIM dan plat nomor, tanggal kedaluwarsa, tanggal mulai dan tanggal perpanjangan, jumlah klaim dan polis.

### ID Klaim
<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 Kebijakan
<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>
```

### Nomor SIM
<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>
```

### Nomor plat
<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>
```

### Tanggal kedaluwarsa kartu kredit
<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>
```

### Tanggal kedaluwarsa kebijakan, day/month/year
<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>
```

### Tanggal perpanjangan polis, bulan/tahun
<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>
```

### Tanggal mulai kebijakan
<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>
```

### Jumlah klaim
<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>
```

### Jumlah premi
<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>
```

### Kuantitas kebijakan
<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>
```

## [Tata bahasa untuk telekomunikasi (unduh)](samples/telecom-grammars.zip)
<a name="telecom-grammers"></a>

Tata bahasa berikut didukung untuk telekomunikasi: Nomor telepon, nomor seri, nomor SIM, kode pos AS, tanggal kedaluwarsa kartu kredit, mulai rencana, tanggal perpanjangan dan kedaluwarsa, tanggal mulai layanan, jumlah peralatan dan jumlah tagihan.

### Nomor telepon
<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>
```

### Nomor seri
<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>
```

### Nomor 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>
```

### Kode pos AS
<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>
```

### Tanggal kedaluwarsa kartu kredit
<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>
```

### Tanggal kedaluwarsa rencana, day/month/year
<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>
```

### Tanggal perpanjangan rencana, bulan/tahun
<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>
```

### Rencanakan tanggal mulai, bulan/hari
<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>
```

### Tanggal mulai layanan, bulan/hari
<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>
```

### Kuantitas peralatan
<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>
```

### Jumlah tagihan
<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>
```

## [Tata bahasa generik (unduh)](samples/generic-grammars.zip)
<a name="generic-grammars"></a>

Kami menyediakan tata bahasa generik berikut: alfanumerik, mata uang, tanggal (mm/dd/yy), angka, salam, ragu-ragu, dan agen.

### Alfanumerik
<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>
```

### Mata Uang
<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>
```

### Tanggal, dd/mm
<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>
```

### Tanggal, mm/yy
<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>
```

### Tanggal, dd/mm/yyyy
<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>
```

### Angka, digit
<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>
```

### Angka, ordinal
<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>
```

### Agen
<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>
```

### Salam
<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>
```

### Keraguan
<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>
```

# Jenis slot komposit
<a name="composite-slots"></a>

Slot komposit adalah kombinasi dari dua slot atau lebih yang menangkap beberapa informasi dalam satu input pengguna. Misalnya, Anda dapat mengonfigurasi bot untuk mendapatkan lokasi dengan meminta “kota dan negara bagian atau kode pos”. Sebaliknya, ketika percakapan dikonfigurasi untuk menggunakan jenis slot terpisah yang menghasilkan pengalaman percakapan yang kaku (“Apa kotanya?” diikuti oleh “Apa kode pos?”). Dengan slot komposit, Anda dapat menangkap semua informasi melalui satu slot. Slot komposit adalah kombinasi slot yang disebut subslot, seperti kota, negara bagian, dan kode pos.

Anda dapat menggunakan kombinasi jenis slot Amazon Lex yang tersedia (built-in) dan slot Anda sendiri (slot khusus). Anda dapat merancang ekspresi logis untuk menangkap informasi dalam subslot yang diperlukan. Misalnya: kota dan negara bagian atau kode pos.

Jenis slot komposit hanya tersedia di en-US.

**Membuat jenis slot komposit**

Untuk menggunakan subslot dalam slot komposit, Anda harus terlebih dahulu mengkonfigurasi jenis slot komposit. Untuk melakukannya, gunakan langkah menambahkan konsol tipe slot atau operasi API. Setelah Anda memilih nama dan deskripsi untuk jenis slot komposit, Anda harus memberikan informasi untuk subslot. Untuk informasi selengkapnya tentang menambahkan jenis slot, lihat [Menambahkan jenis slot](add-slot-types.md) 

**Subslot**

Jenis slot komposit membutuhkan konfigurasi slot yang mendasarinya, yang disebut subslot. Jika Anda ingin memperoleh banyak informasi dari pelanggan dalam satu permintaan, konfigurasikan kombinasi subslot. Misalnya: kota, negara bagian, dan kode pos. Anda dapat menambahkan hingga 6 subslot untuk slot komposit.

Slot jenis slot tunggal dapat digunakan untuk menambahkan subslot ke jenis slot komposit. Namun, Anda tidak dapat menggunakan jenis slot komposit sebagai jenis slot untuk subslot.

Gambar-gambar berikut adalah ilustrasi slot komposit “Mobil”, yang merupakan kombinasi dari subslot: Warna,, Pabrikan FuelType, Model, VIN, dan Tahun.

![\[Panel tipe slot menunjukkan subslot.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/cst-slottype.png)


![\[Panel subslot.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/cst-subslots.png)


**Pembuat ekspresi**

Untuk mendorong pemenuhan slot komposit, Anda dapat menggunakan pembuat ekspresi secara opsional. Dengan pembuat ekspresi, Anda dapat mendesain ekspresi slot logis untuk menangkap nilai subslot yang diperlukan dalam urutan yang diinginkan. Sebagai bagian dari ekspresi boolean, Anda dapat menggunakan operator seperti AND dan OR. Berdasarkan ekspresi yang dirancang, ketika subslot yang diperlukan terpenuhi, slot komposit dianggap terpenuhi.

**Menggunakan jenis slot komposit**

Untuk beberapa maksud, Anda mungkin ingin menangkap slot yang berbeda sebagai bagian dari satu slot. Misalnya, bot penjadwalan perawatan mobil mungkin memiliki maksud dengan ucapan berikut:

`My car is a {car}`

Maksudnya mengharapkan bahwa slot komposit \$1car\$1 berisi daftar slot, yang terdiri dari detail mobil. Misalnya, “2021 White Toyota Camry”.

Slot komposit berbeda dari slot multi-nilai. Slot komposit terdiri dari beberapa slot, masing-masing dengan nilainya sendiri. Padahal, slot multi-nilai adalah slot tunggal yang dapat berisi daftar nilai. Untuk informasi lebih lanjut tentang slot multi-nilai lihat, [Menggunakan beberapa nilai dalam slot](multi-valued-slots.md)

Untuk slot komposit, Amazon Lex mengembalikan nilai untuk setiap subslot sebagai respons terhadap `RecognizeUtterance` operasi `RecognizeText` atau. Berikut ini adalah informasi slot yang dikembalikan untuk ucapan: “Saya ingin menjadwalkan layanan untuk” 2021 White Toyota Camry “saya dari bot. CarService 

```
"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"
            }
        }
    },
    ...
}
```

Slot komposit dapat diperoleh pada giliran pertama atau giliran ke-n percakapan. Berdasarkan nilai input yang diberikan, slot komposit dapat memperoleh subslot yang diperlukan yang tersisa.

Slot komposit selalu mengembalikan nilai untuk setiap subslot. Ketika ucapan tidak mengandung nilai yang dapat dikenali untuk subslot tertentu, tidak ada respons yang dikembalikan untuk subslot tertentu.

Slot komposit bekerja dengan input teks dan suara.

Saat menambahkan slot ke intent, slot komposit hanya tersedia sebagai jenis slot khusus.

Anda dapat menggunakan slot Komposit dalam petunjuk. Misalnya, Anda dapat mengatur prompt konfirmasi untuk maksud.

`Would you like me to schedule service for your 2021 White Toyota Camry?`

Ketika Amazon Lex mengirimkan prompt kepada pengguna, ia mengirimkan “Apakah Anda ingin saya menjadwalkan layanan untuk Toyota Camry Putih 2021 Anda?”

Setiap subslot dikonfigurasi sebagai slot. Anda dapat menambahkan petunjuk slot untuk mendapatkan subslot dan contoh ucapan. Anda dapat mengaktifkan tunggu dan melanjutkan untuk subslot serta nilai default. Untuk informasi selengkapnya, lihat [Menggunakan nilai slot default dalam maksud untuk bot Lex V2 Anda](context-mgmt-default.md)

![\[Panel pengaturan slot komposit\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/cst-composite.png)


Anda dapat menggunakan slot obfuscation untuk menutupi seluruh slot komposit di log percakapan. Harap dicatat bahwa pengaburan slot diterapkan pada level slot komposit dan ketika diaktifkan, nilai untuk subslot milik slot komposit dikaburkan. Saat Anda mengaburkan nilai slot, nilai masing-masing nilai slot diganti dengan nama slot. Untuk informasi selengkapnya, lihat [Mengaburkan nilai slot dalam log percakapan dari Lex V2](monitoring-obfuscate.md).

![\[Panel info slot komposit\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/cst-slotinfo.png)


**Mengedit jenis slot komposit**

Anda dapat mengedit subslot dari dalam konfigurasi slot komposit untuk memodifikasi nama subslot dan jenis slot. Namun, ketika slot komposit digunakan oleh maksud, Anda harus mengedit intent sebelum memodifikasi subslot.

![\[Panel peringatan untuk maksud yang ada\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/cst-alert.png)


**Menghapus jenis slot komposit**

Anda dapat menghapus subslot dari dalam konfigurasi slot komposit. Harap dicatat bahwa ketika subslot digunakan dalam maksud, subslot masih dihapus dari maksud tersebut.

![\[Hapus maksud dengan subslot\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/cst-delete.png)


Ekspresi slot di pembuat ekspresi memberikan peringatan untuk menginformasikan tentang subslot yang dihapus.

![\[Jenis slot untuk maksud yang ada\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/cst-slottype.png)


# Menguji bot menggunakan konsol
<a name="test-bot"></a>

Konsol Amazon Lex V2 berisi jendela uji yang dapat Anda gunakan untuk menguji interaksi dengan bot Anda. Anda menggunakan jendela uji untuk melakukan percakapan uji dengan bot Anda dan untuk melihat tanggapan yang diterima aplikasi Anda dari bot.

Ada dua jenis pengujian yang dapat Anda lakukan dengan bot Anda. Yang pertama, pengujian ekspres, memungkinkan Anda untuk menguji bot Anda dengan frasa yang tepat yang Anda gunakan untuk membuat bot. Misalnya, jika Anda menambahkan ucapan “Saya ingin mengambil bunga” ke maksud Anda, Anda dapat menguji bot menggunakan frasa yang tepat.

Tipe kedua, pengujian lengkap, memungkinkan Anda untuk menguji bot Anda menggunakan frasa yang terkait dengan ucapan yang Anda konfigurasi. Misalnya, Anda dapat menggunakan frasa “Bisakah saya memesan bunga” untuk memulai percakapan dengan bot Anda.

Anda menguji bot menggunakan alias dan bahasa tertentu. Jika Anda menguji versi pengembangan bot, Anda menggunakan `TestBotAlias` alias untuk pengujian.

**Untuk membuka jendela uji**

1. Masuk ke AWS Management Console dan buka konsol Amazon Lex di [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).

1. Pilih bot yang akan diuji dari daftar bot.

1. Dari menu sebelah kiri, pilih **Alias**.

1. Dari daftar alias, pilih alias untuk diuji.

1. Dari **Bahasa**, pilih tombol radio bahasa yang akan diuji, lalu pilih **Uji**.

Setelah Anda memilih **Uji**, jendela tes terbuka di konsol. Anda dapat menggunakan jendela uji untuk berinteraksi dengan bot Anda, seperti yang ditunjukkan pada grafik berikut.

![\[Jendela uji menunjukkan percakapan dengan bot bunga pesanan.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/test-example-1.png)


Selain percakapan, Anda juga dapat memilih **Periksa** di jendela pengujian untuk melihat respons yang dikembalikan dari bot. Tampilan pertama menunjukkan ringkasan informasi yang dikembalikan dari bot Anda ke jendela pengujian.

![\[Jendela pengujian yang menunjukkan tampilan ringkasan percakapan dengan bot.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/test-example-2.png)


Anda juga dapat menggunakan jendela inspeksi pengujian untuk melihat struktur JSON yang dikirim antara bot dan jendela pengujian. Anda dapat melihat permintaan dari jendela pengujian dan respons dari Amazon Lex V2.

![\[Jendela pengujian yang menunjukkan struktur JSON yang digunakan dalam percakapan dengan bot.\]](http://docs.aws.amazon.com/id_id/lexv2/latest/dg/images/test-example-3.png)
